@doist/doistbot-cli 1.0.5 → 1.0.7

package/sandbox/dist/tasks/persist-logs/llm-query-planner.js

@@ -3,17 +3,17 @@ import path from 'path';
 import { logger } from '../../core/logging.js';
 import { invokePiPrompt } from '../../core/pi.js';
 import { scrubPii } from '../../core/pii-scrubber.js';
-import { loadPromptTemplateFile } from '../../core/prompt-template.js';
+import { loadPromptTemplateFile, resolvePromptFile } from '../../core/prompt-template.js';
 import { startDdProxy } from './dd-proxy.js';
 export const PERSIST_LOGS_PROVIDER = 'openai';
 const TIMEOUT_MS = 20 * 60 * 1000; // 20 minutes — investigation can take a while
 function buildPrompt(params, proxyPort) {
     const ddApiReference = loadPromptTemplateFile({
-        fileName: 'persist-logs-dd-api-reference.md',
+        fileName: resolvePromptFile(import.meta.url, 'persist-logs-dd-api-reference.md'),
         promptLabel: 'persist-logs DD API reference',
     });
     const template = loadPromptTemplateFile({
-        fileName: 'persist-logs-investigation-prompt.md',
+        fileName: resolvePromptFile(import.meta.url, 'persist-logs-investigation-prompt.md'),
         promptLabel: 'persist-logs investigation prompt',
     });
     const scrubbedTitle = scrubPii(params.issueTitle);

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

@@ -135,7 +135,7 @@ export function buildSuccessSummary(review, pullRequestUrl, counts = countFindin
  * PR conversation comment.
  */
 async function postReviewCheckRun(params) {
-    const { octokit, owner, repo, sha, pullNumber, deliveryId, title, summaryBody } = params;
+    const { octokit, owner, repo, sha, pullNumber, deliveryId, checkRunId, title, summaryBody } = params;
     const pullRequestUrl = `https://github.com/${owner}/${repo}/pull/${pullNumber}`;
     const summary = appendReviewFeedbackLink(summaryBody, {
         owner,
@@ -153,6 +153,7 @@ async function postReviewCheckRun(params) {
         detailsUrl: pullRequestUrl,
         name: CHECK_RUN_NAME,
         externalId: deliveryId,
+        checkRunId,
     };
     if (params.status === 'in_progress') {
         await postCheckRun({ ...sharedArgs, status: 'in_progress' });

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

@@ -4,6 +4,7 @@ import { logger } from '../../core/logging.js';
 import { invokePiPrompt } from '../../core/pi.js';
 import { WORKSPACE_DIR } from '../../core/shared.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.
@@ -36,7 +37,7 @@ function shouldMaskPrAuthor(login, prAuthor) {
     return Boolean(normalizedLogin && normalizedPrAuthor && normalizedLogin === normalizedPrAuthor);
 }
 function cleanBody(body) {
-    return stripReviewFeedbackFooter(body);
+    return normalizeGithubPriorityBadges(stripReviewFeedbackFooter(body));
 }
 function toIssueCommentEntry(comment) {
     const author = comment.user?.login ?? 'unknown';

package/sandbox/dist/tasks/review/engines/dedupe.js

@@ -1,18 +1,74 @@
+import { SpanStatusCode } from '@opentelemetry/api';
 import { logger } from '../../../core/logging.js';
 import { invokePiPrompt } from '../../../core/pi.js';
 import { logPiProgressEvent } from '../../../core/pi-progress-logging.js';
+import { genAiProviderName, withPhase } from '../../../core/tracing.js';
 import { resolveReviewProviderCredential } from '../../../providers/credentials.js';
-import { extractJsonFromResponse } from '../../../providers/helpers.js';
+import { extractJsonFromResponse, readProviderErrorDetails } from '../../../providers/helpers.js';
 import { isDedupeResponse } from '../../../providers/schemas.js';
 const DEDUPE_TIMEOUT_MS = 5 * 60 * 1000;
 const DEDUPE_PROVIDER = 'gemini';
 const DEDUPE_MODEL_BY_PI_PROVIDER = {
+    google: 'gemini-3-flash-preview',
     openrouter: 'google/gemini-3-flash-preview',
 };
 const DEDUPE_THINKING_LEVEL = 'medium';
 const DEDUPE_MAX_ATTEMPTS = 2;
 const DEDUPE_RETRY_DELAY_MS = 1_000;
 const DEDUPE_SYSTEM_PROMPT = 'You are a JSON-only duplicate-finding classifier. Use only the findings JSON in the user prompt. Do not inspect files, do not search the repository, and do not use tools. Return only valid JSON matching the requested schema.';
+const DEDUPE_PHASE = 'review.dedupe';
+const DEDUPE_PROVIDER_UNAVAILABLE_LOG_TYPE = 'review.dedupe.provider_unavailable';
+function getDedupeProviderRoute(providerConfig) {
+    return providerConfig.piProviderId ?? 'google';
+}
+function toDedupeProviderConfig(credential, piProviderId) {
+    return {
+        provider: DEDUPE_PROVIDER,
+        apiKey: credential.apiKey,
+        ...(piProviderId === 'google' ? {} : { piProviderId }),
+        modelName: DEDUPE_MODEL_BY_PI_PROVIDER[piProviderId] ?? DEDUPE_MODEL_BY_PI_PROVIDER.google,
+    };
+}
+function buildOpenRouterDedupeProviderConfig(credential) {
+    const resolvedCredential = resolveReviewProviderCredential(credential);
+    if (!resolvedCredential) {
+        return undefined;
+    }
+    return toDedupeProviderConfig(resolvedCredential, 'openrouter');
+}
+function buildDedupeProviderConfigs({ geminiCredential, openRouterCredential, }) {
+    const primaryPiProviderId = geminiCredential.piProviderId ?? 'google';
+    const primaryConfig = toDedupeProviderConfig(geminiCredential, primaryPiProviderId);
+    const openRouterConfig = primaryPiProviderId === 'openrouter'
+        ? undefined
+        : buildOpenRouterDedupeProviderConfig(openRouterCredential);
+    return openRouterConfig ? [primaryConfig, openRouterConfig] : [primaryConfig];
+}
+function logDedupeProviderUnavailable({ providerConfig, attempt, error, shouldRetry, timedOut, }) {
+    const details = readProviderErrorDetails(error);
+    function log(message, meta) {
+        if (shouldRetry) {
+            logger.warn(message, meta);
+        }
+        else {
+            logger.error(message, meta);
+        }
+    }
+    log('Multi-focus dedupe provider unavailable', {
+        type: DEDUPE_PROVIDER_UNAVAILABLE_LOG_TYPE,
+        provider: providerConfig.provider,
+        provider_route: getDedupeProviderRoute(providerConfig),
+        model: providerConfig.modelName,
+        attempt,
+        attempts_total: DEDUPE_MAX_ATTEMPTS,
+        retrying: shouldRetry,
+        error_code: details.errorCode,
+        status: details.status,
+        reason: details.reason,
+        error: details.rawError,
+        timed_out: timedOut ?? false,
+    });
+}
 function buildDedupePrompt(findings) {
     const payload = {
         findings: findings.map((finding) => ({
@@ -109,14 +165,14 @@ export function applyDedupeGroups(findings, groups) {
     });
     return findings.filter((finding) => !dropped.has(finding.id));
 }
-export async function dedupeMultiFocusFindings({ findings, availableModels, workspaceDir, geminiCredential, }) {
+export async function dedupeMultiFocusFindings({ findings, availableModels, workspaceDir, geminiCredential, openRouterCredential, }) {
     if (findings.length <= 1) {
         return findings;
     }
     if (!availableModels.includes(DEDUPE_PROVIDER)) {
         logger.error('Multi-focus dedupe unavailable because Gemini is not enabled', {
             provider: DEDUPE_PROVIDER,
-            model: DEDUPE_MODEL_BY_PI_PROVIDER.openrouter,
+            model: DEDUPE_MODEL_BY_PI_PROVIDER.google,
         });
         throw new Error('Multi-focus dedupe requires Gemini to be enabled');
     }
@@ -124,49 +180,62 @@ export async function dedupeMultiFocusFindings({ findings, availableModels, work
     if (!credential) {
         logger.error('Multi-focus dedupe unavailable because Gemini review credential is unavailable', {
             provider: DEDUPE_PROVIDER,
-            model: DEDUPE_MODEL_BY_PI_PROVIDER.openrouter,
+            model: DEDUPE_MODEL_BY_PI_PROVIDER.google,
         });
         throw new Error('Multi-focus dedupe requires a Gemini review credential');
     }
-    const piProviderId = credential.piProviderId ?? 'openrouter';
-    const providerConfig = {
-        provider: DEDUPE_PROVIDER,
-        apiKey: credential.apiKey,
-        ...(credential.piProviderId ? { piProviderId: credential.piProviderId } : {}),
-        modelName: DEDUPE_MODEL_BY_PI_PROVIDER[piProviderId] ?? DEDUPE_MODEL_BY_PI_PROVIDER.openrouter,
-    };
+    return runDedupeAttempts({
+        findings,
+        workspaceDir,
+        providerConfigs: buildDedupeProviderConfigs({
+            geminiCredential: credential,
+            openRouterCredential,
+        }),
+    });
+}
+async function runDedupeAttempts({ findings, workspaceDir, providerConfigs, }) {
     for (let attempt = 1; attempt <= DEDUPE_MAX_ATTEMPTS; attempt += 1) {
+        const providerConfig = providerConfigs[Math.min(attempt - 1, providerConfigs.length - 1)];
         let result;
         try {
-            result = await invokePiPrompt({
-                provider: providerConfig.provider,
-                apiKey: providerConfig.apiKey,
-                ...(providerConfig.piProviderId
-                    ? { piProviderId: providerConfig.piProviderId }
-                    : {}),
-                prompt: buildDedupePrompt(findings),
-                cwd: workspaceDir,
-                timeoutMs: DEDUPE_TIMEOUT_MS,
-                capabilityPreset: 'read-only',
-                modelName: providerConfig.modelName,
-                thinkingLevel: DEDUPE_THINKING_LEVEL,
-                systemPrompt: DEDUPE_SYSTEM_PROMPT,
-                onProgress: (event) => {
-                    logDedupeProgress(providerConfig, event);
-                },
+            // One span per actual invoke: a fail-then-succeed retry shows up as a
+            // separate error span and ok span, not one inflated span. Provider/
+            // model are known here, so the span carries full gen_ai.*.
+            result = await withPhase(DEDUPE_PHASE, {
+                'gen_ai.operation.name': 'chat',
+                'gen_ai.provider.name': genAiProviderName(providerConfig.provider),
+                'gen_ai.request.model': providerConfig.modelName,
+                'review.provider_route': getDedupeProviderRoute(providerConfig),
+            }, async (span) => {
+                const invocation = await invokePiPrompt({
+                    provider: providerConfig.provider,
+                    apiKey: providerConfig.apiKey,
+                    ...(providerConfig.piProviderId
+                        ? { piProviderId: providerConfig.piProviderId }
+                        : {}),
+                    prompt: buildDedupePrompt(findings),
+                    cwd: workspaceDir,
+                    timeoutMs: DEDUPE_TIMEOUT_MS,
+                    capabilityPreset: 'read-only',
+                    modelName: providerConfig.modelName,
+                    thinkingLevel: DEDUPE_THINKING_LEVEL,
+                    systemPrompt: DEDUPE_SYSTEM_PROMPT,
+                    onProgress: (event) => {
+                        logDedupeProgress(providerConfig, event);
+                    },
+                });
+                if (!invocation.ok) {
+                    span.setStatus({
+                        code: SpanStatusCode.ERROR,
+                        message: invocation.error ?? 'dedupe request failed',
+                    });
+                }
+                return invocation;
             });
         }
         catch (error) {
             const shouldRetry = attempt < DEDUPE_MAX_ATTEMPTS;
-            logger.warn(shouldRetry
-                ? 'Multi-focus dedupe request threw, retrying'
-                : 'Multi-focus dedupe request threw', {
-                provider: providerConfig.provider,
-                model: providerConfig.modelName,
-                attempt,
-                attempts_total: DEDUPE_MAX_ATTEMPTS,
-                error: error instanceof Error ? error.message : String(error),
-            });
+            logDedupeProviderUnavailable({ providerConfig, attempt, error, shouldRetry });
             if (shouldRetry) {
                 await waitForDedupeRetry(attempt);
                 continue;
@@ -175,15 +244,12 @@ export async function dedupeMultiFocusFindings({ findings, availableModels, work
         }
         if (!result.ok) {
             const shouldRetry = attempt < DEDUPE_MAX_ATTEMPTS;
-            logger.warn(shouldRetry
-                ? 'Multi-focus dedupe request failed, retrying'
-                : 'Multi-focus dedupe request failed', {
-                provider: providerConfig.provider,
-                model: providerConfig.modelName,
+            logDedupeProviderUnavailable({
+                providerConfig,
                 attempt,
-                attempts_total: DEDUPE_MAX_ATTEMPTS,
-                error: result.error,
-                timed_out: result.timedOut,
+                error: result.error ?? 'dedupe request failed',
+                shouldRetry,
+                timedOut: result.timedOut,
             });
             if (shouldRetry) {
                 await waitForDedupeRetry(attempt);