@doist/doistbot-cli 1.0.5 → 1.0.7

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

@@ -1,13 +1,15 @@
+import { createHash } from 'crypto';
 import fs from 'fs';
 import { logger } from '../../core/logging.js';
-import { hasReviewProviderCredential } from '../../providers/credentials.js';
 import { runMultiFocusReviewEngine } from './engines/multi-focus.js';
+import { getEnabledReviewModels } from './engines/shared.js';
 import {} from './engines/types.js';
 import { buildAnnotatedDiff, buildDiffSection } from './diff.js';
 import { buildMultiFocusSharedPrompt } from './multi-focus-prompt.js';
 import { loadStandardsSection } from './prompt.js';
 const REVIEW_GUIDANCE_FILES = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'];
 const MASKED_PR_AUTHOR_LABEL = 'PR author';
+const OPENROUTER_SESSION_REPO_SEGMENT_MAX_LENGTH = 96;
 function getGuidanceFilePresence(workspaceDir) {
     return Object.fromEntries(REVIEW_GUIDANCE_FILES.map((fileName) => [
         fileName,
@@ -47,12 +49,23 @@ function buildEnginePrompt({ input, diffSection, truncated, standardsSection, pr
         prompt: buildMultiFocusSharedPrompt(sharedPromptArgs),
     };
 }
-function getEnabledReviewModels({ apiKeys, reviewModelsEnabled, }) {
-    return reviewModelsEnabled.filter((model) => hasReviewProviderCredential(apiKeys[model]));
-}
 function getMissingRequiredReviewModels(availableModels, requiredReviewModels = []) {
     return requiredReviewModels.filter((model) => !availableModels.includes(model));
 }
+function toOpenRouterSessionSegment(value, fallback) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, OPENROUTER_SESSION_REPO_SEGMENT_MAX_LENGTH);
+    return normalized || fallback;
+}
+export function buildOpenRouterReviewSessionId({ owner, repo, prNumber, prompt, }) {
+    const repoSegment = toOpenRouterSessionSegment(`${owner}-${repo}`, 'repo');
+    const promptHash = createHash('sha256').update(prompt).digest('hex').slice(0, 32);
+    return `doistbot-review-${repoSegment}-pr-${prNumber}-${promptHash}`;
+}
 export async function runSharedReview(input) {
     const { annotatedFiles, lineLookup } = buildAnnotatedDiff(input.files);
     if (annotatedFiles.length === 0) {
@@ -76,10 +89,11 @@ export async function runSharedReview(input) {
             providerFailures: [],
         };
     }
-    const configuredAvailableModels = getEnabledReviewModels(input);
+    const configuredAvailableModels = getEnabledReviewModels(input.apiKeys, input.reviewModelsEnabled);
     if (configuredAvailableModels.length === 0) {
         logger.error('No enabled review models with API keys are available, skipping review', {
             review_models_enabled: input.reviewModelsEnabled,
+            review_focuses_enabled: input.reviewFocusesEnabled,
         });
         return {
             status: 'skipped',
@@ -94,6 +108,7 @@ export async function runSharedReview(input) {
     if (missingRequiredModels.length > 0) {
         logger.error('Required review models with API keys are unavailable, skipping review', {
             review_models_enabled: input.reviewModelsEnabled,
+            review_focuses_enabled: input.reviewFocusesEnabled,
             available_models: configuredAvailableModels,
             missing_required_models: missingRequiredModels,
         });
@@ -134,9 +149,19 @@ export async function runSharedReview(input) {
         repo: input.repo,
         prNumber: input.prNumber,
         workspaceDir: input.workspaceDir,
-        geminiCredential: input.apiKeys.gemini,
-        openaiApiKey: input.apiKeys.openai,
+        apiKeys: input.apiKeys,
         reviewModelsEnabled: input.reviewModelsEnabled,
+        ...(input.reviewModelsByFocus ? { reviewModelsByFocus: input.reviewModelsByFocus } : {}),
+        ...(input.geminiFallbackFocuses
+            ? { geminiFallbackFocuses: input.geminiFallbackFocuses }
+            : {}),
+        ...(input.reviewSummaryModel ? { reviewSummaryModel: input.reviewSummaryModel } : {}),
+        openRouterSessionId: buildOpenRouterReviewSessionId({
+            owner: input.owner,
+            repo: input.repo,
+            prNumber: input.prNumber,
+            prompt,
+        }),
     };
     const { review, availableModels, metricModels, mode, providerFailures } = await runMultiFocusReviewEngine({
         ctx: engineContext,
@@ -146,6 +171,7 @@ export async function runSharedReview(input) {
         prTitle: input.prTitle,
         prBody: input.prBody,
         lowPriorityFindingPlacement: input.lowPriorityFindingPlacement,
+        enabledFocuses: input.reviewFocusesEnabled,
         onProgress: input.onProgress,
     });
     if (availableModels.length === 0) {

package/sandbox/dist/tasks/review/summary-model.js

@@ -1,8 +1,14 @@
+import { SpanStatusCode } from '@opentelemetry/api';
 import { logger } from '../../core/logging.js';
-import { invokePiPrompt } from '../../core/pi.js';
+import { DEFAULT_GEMINI_FLASH_MODEL, DEFAULT_OPENROUTER_MODELS, DEFAULT_PI_MODELS, invokePiPrompt, PI_PROVIDER_BY_DOISTBOT_PROVIDER, } from '../../core/pi.js';
 import { WORKSPACE_DIR } from '../../core/shared.js';
+import { genAiProviderName, withPhase } from '../../core/tracing.js';
 import { resolveReviewProviderCredential } from '../../providers/credentials.js';
+import { extractJsonCandidatesFromResponse } from '../../providers/helpers.js';
 const REVIEW_SUMMARY_TIMEOUT_MS = 5 * 60 * 1000;
+const REVIEW_SUMMARY_THINKING_LEVEL = 'medium';
+// One model span per summary attempt; a fallback chain emits one span per model.
+const SUMMARY_PHASE = 'review.summary';
 const DIFF_SIDE = {
     LEFT: 'LEFT',
     RIGHT: 'RIGHT',
@@ -10,53 +16,216 @@ const DIFF_SIDE = {
 function getWorkspaceDir() {
     return WORKSPACE_DIR;
 }
-export async function requestReviewSummary({ credential, prompt, workspaceDir, }) {
-    try {
-        const resolvedCredential = resolveReviewProviderCredential(credential);
-        if (!resolvedCredential) {
-            return null;
+function getReviewSummaryModelNameForLog({ provider, piProviderId, modelName, }) {
+    if (modelName) {
+        return modelName;
+    }
+    const resolvedPiProviderId = piProviderId ?? PI_PROVIDER_BY_DOISTBOT_PROVIDER[provider];
+    return ((resolvedPiProviderId === 'openrouter' ? DEFAULT_OPENROUTER_MODELS[provider] : undefined) ??
+        DEFAULT_PI_MODELS[provider]);
+}
+export function buildGeminiFlashReviewSummaryModel(credential) {
+    if (credential === undefined) {
+        return undefined;
+    }
+    const resolvedCredential = resolveReviewProviderCredential(credential);
+    if (!resolvedCredential) {
+        return undefined;
+    }
+    return {
+        provider: 'gemini',
+        credential,
+        modelName: DEFAULT_GEMINI_FLASH_MODEL,
+    };
+}
+function failedReviewSummaryRequest({ reason, error, timedOut, durationMs, outputChars, }) {
+    return {
+        status: 'failed',
+        reason,
+        ...(error ? { error } : {}),
+        ...(timedOut !== undefined ? { timedOut } : {}),
+        ...(durationMs !== undefined ? { durationMs } : {}),
+        ...(outputChars !== undefined ? { outputChars } : {}),
+    };
+}
+function getRequestFailureReason(result) {
+    if (result.timedOut) {
+        return 'timeout';
+    }
+    return result.error.toLowerCase().includes('did not produce an assistant response')
+        ? 'no_assistant_response'
+        : 'request_failed';
+}
+export async function requestReviewSummary({ credential, provider = 'zai', modelName, prompt, workspaceDir, }) {
+    const resolvedCredential = resolveReviewProviderCredential(credential);
+    if (!resolvedCredential) {
+        return failedReviewSummaryRequest({ reason: 'missing_credential' });
+    }
+    const resolvedModelName = modelName ?? resolvedCredential.modelName;
+    const logModelName = getReviewSummaryModelNameForLog({
+        provider,
+        piProviderId: resolvedCredential.piProviderId,
+        modelName: resolvedModelName,
+    });
+    // Span wraps the actual model invoke (after the credential check), so a
+    // missing-credential config error returns before any span and never shows a fake model attempt.
+    return withPhase(SUMMARY_PHASE, {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': genAiProviderName(provider),
+        'gen_ai.request.model': logModelName,
+    }, async (span) => {
+        const result = await runReviewSummaryRequest({
+            provider,
+            resolvedCredential,
+            resolvedModelName,
+            logModelName,
+            prompt,
+            workspaceDir,
+        });
+        if (result.status === 'failed') {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: result.error ?? result.reason,
+            });
         }
+        return result;
+    });
+}
+async function runReviewSummaryRequest({ provider, resolvedCredential, resolvedModelName, logModelName, prompt, workspaceDir, }) {
+    try {
+        logger.info('Review summary model request', {
+            provider,
+            modelName: logModelName,
+            promptLength: prompt.length,
+            timeoutMs: REVIEW_SUMMARY_TIMEOUT_MS,
+            thinkingLevel: REVIEW_SUMMARY_THINKING_LEVEL,
+        });
         const result = await invokePiPrompt({
-            provider: 'gemini',
+            provider,
             apiKey: resolvedCredential.apiKey,
             ...(resolvedCredential.piProviderId
                 ? { piProviderId: resolvedCredential.piProviderId }
                 : {}),
-            ...(resolvedCredential.modelName ? { modelName: resolvedCredential.modelName } : {}),
+            ...(resolvedModelName ? { modelName: resolvedModelName } : {}),
             prompt,
             cwd: workspaceDir ?? getWorkspaceDir(),
             timeoutMs: REVIEW_SUMMARY_TIMEOUT_MS,
             capabilityPreset: 'read-only',
+            thinkingLevel: REVIEW_SUMMARY_THINKING_LEVEL,
         });
         if (!result.ok) {
+            const reason = getRequestFailureReason(result);
             logger.warn('Review summary model request failed', {
+                reason,
+                provider,
+                modelName: logModelName,
+                error: result.error,
+                timedOut: result.timedOut,
+                durationMs: result.durationMs,
+                promptLength: prompt.length,
+            });
+            return failedReviewSummaryRequest({
+                reason,
                 error: result.error,
                 timedOut: result.timedOut,
+                durationMs: result.durationMs,
             });
-            return null;
         }
         const output = result.output;
         if (!output?.trim()) {
-            return null;
+            return failedReviewSummaryRequest({
+                reason: 'empty_output',
+                durationMs: result.durationMs,
+                outputChars: output?.length ?? 0,
+            });
+        }
+        const jsonCandidates = extractJsonCandidatesFromResponse(output);
+        if (jsonCandidates.length === 0) {
+            logger.warn('Review summary model output missing JSON', {
+                provider,
+                modelName: logModelName,
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+            return failedReviewSummaryRequest({
+                reason: 'missing_json',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+        }
+        let parsed;
+        let parsedSuccessfully = false;
+        let parseError;
+        for (const jsonCandidate of jsonCandidates) {
+            try {
+                parsed = JSON.parse(jsonCandidate);
+                parsedSuccessfully = true;
+                break;
+            }
+            catch (error) {
+                parseError = error;
+            }
+        }
+        if (!parsedSuccessfully) {
+            logger.warn('Review summary model output contained invalid JSON', {
+                provider,
+                modelName: logModelName,
+                error: parseError instanceof Error ? parseError.message : String(parseError),
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+            return failedReviewSummaryRequest({
+                reason: 'invalid_json',
+                error: parseError instanceof Error ? parseError.message : String(parseError),
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
         }
-        const start = output.indexOf('{');
-        const end = output.lastIndexOf('}');
-        if (start === -1 || end === -1 || end <= start) {
-            logger.warn('Review summary model output missing JSON delimiters');
-            return null;
+        if (!parsed || typeof parsed !== 'object') {
+            return failedReviewSummaryRequest({
+                reason: 'invalid_schema',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
         }
-        const jsonText = output.slice(start, end + 1);
-        const parsed = JSON.parse(jsonText);
+        const summaryResult = parsed;
+        if (typeof summaryResult.summary !== 'string') {
+            return failedReviewSummaryRequest({
+                reason: 'invalid_schema',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+        }
+        if (!summaryResult.summary.trim()) {
+            return failedReviewSummaryRequest({
+                reason: 'empty_summary',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+        }
+        logger.info('Review summary model response', {
+            provider,
+            modelName: logModelName,
+            durationMs: result.durationMs,
+            outputChars: output.length,
+            summaryChars: summaryResult.summary.trim().length,
+        });
         return {
-            summary: typeof parsed.summary === 'string' ? parsed.summary : '',
-            comments: Array.isArray(parsed.comments) ? parsed.comments : [],
+            status: 'succeeded',
+            summary: summaryResult.summary,
+            comments: Array.isArray(summaryResult.comments) ? summaryResult.comments : [],
+            durationMs: result.durationMs,
+            outputChars: output.length,
         };
     }
     catch (error) {
         logger.error('Review summary model request or parsing failed', {
             error: error instanceof Error ? error.message : String(error),
         });
-        return null;
+        return failedReviewSummaryRequest({
+            reason: 'request_failed',
+            error: error instanceof Error ? error.message : String(error),
+        });
     }
 }
 export function sanitizeInlineComments(comments, lineLookup) {

package/sandbox/dist/tasks/review/thinking-level.js

@@ -1,7 +1,11 @@
 export function getReviewThinkingLevel(model) {
     switch (model) {
+        case 'deepseek':
+            return 'high';
         case 'openai':
             return 'high';
+        case 'zai':
+            return 'high';
         case 'gemini':
             return 'high';
     }

package/sandbox/node_modules/doistbot-repo-config/dist/index.d.ts

@@ -1,12 +1,8 @@
 import type { Logger } from 'doistbot-logging';
 import type { Octokit } from 'octokit';
 export declare const CONFIG_FILE_PATH = ".github/doistbot.yml";
-export declare const DEFAULT_REVIEW_MODELS: readonly ["gemini", "openai"];
-export declare const REQUIRED_REVIEW_MODELS: readonly ["gemini", "openai"];
-type ParseReviewModelsEnabledOptions = {
-    defaultModels?: readonly string[];
-    requiredModels?: readonly string[];
-};
+export declare const DEFAULT_REVIEW_MODELS: readonly ["openai", "deepseek", "zai"];
+export type DefaultReviewModel = (typeof DEFAULT_REVIEW_MODELS)[number];
 export type RepoConfig = {
     review?: {
         skip_forks?: boolean;
@@ -50,6 +46,6 @@ export declare function getLocalRepoConfig({ workspaceDir, logger, }: {
     workspaceDir: string;
     logger: Logger;
 }): RepoConfig | null;
-export declare function parseReviewModelsEnabled(raw: string | undefined, { defaultModels, requiredModels, }?: ParseReviewModelsEnabledOptions): string[];
-export declare function getDefaultReviewModels(): string[];
+export declare function getDefaultReviewModels(): DefaultReviewModel[];
+export declare function parseReviewModelsEnabled(value: string | undefined): string[];
 export {};

package/sandbox/node_modules/doistbot-repo-config/dist/index.js

@@ -2,8 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { load as yamlLoad } from 'js-yaml';
 export const CONFIG_FILE_PATH = '.github/doistbot.yml';
-export const DEFAULT_REVIEW_MODELS = ['gemini', 'openai'];
-export const REQUIRED_REVIEW_MODELS = DEFAULT_REVIEW_MODELS;
+export const DEFAULT_REVIEW_MODELS = ['openai', 'deepseek', 'zai'];
 function parseRepoConfigContent(content) {
     return yamlLoad(content);
 }
@@ -91,24 +90,13 @@ export function getLocalRepoConfig({ workspaceDir, logger, }) {
         return null;
     }
 }
-export function parseReviewModelsEnabled(raw, { defaultModels = DEFAULT_REVIEW_MODELS, requiredModels = REQUIRED_REVIEW_MODELS, } = {}) {
-    if (!raw?.trim()) {
-        return [...defaultModels];
-    }
-    const allowedModels = new Set(DEFAULT_REVIEW_MODELS);
-    const models = [];
-    for (const token of raw.split(',')) {
-        const model = token.trim().toLowerCase();
-        if (!model || !allowedModels.has(model)) {
-            continue;
-        }
-        if (!models.includes(model)) {
-            models.push(model);
-        }
-    }
-    const hasRequiredModels = requiredModels.every((model) => models.includes(model));
-    return models.length > 0 && hasRequiredModels ? models : [...defaultModels];
-}
 export function getDefaultReviewModels() {
     return [...DEFAULT_REVIEW_MODELS];
 }
+export function parseReviewModelsEnabled(value) {
+    const models = value
+        ?.split(',')
+        .map((model) => model.trim())
+        .filter(Boolean) ?? [];
+    return models.length > 0 ? [...new Set(models)] : getDefaultReviewModels();
+}

package/sandbox/src/tasks/review/prompts/review-multi-focus-base-prompt.md

@@ -71,6 +71,7 @@ $DIFF_SECTION
 - Use one comment per distinct issue.
 - Ignore trivial style unless it obscures meaning or violates documented standards.
 - Keep code ranges tight and comments easy to understand without close reading.
+- **Do not flag dependency or tooling versions as nonexistent, outdated, or "too new."** Your training data has a cutoff, so you can't know which versions of GitHub Actions, npm/PyPI/etc. packages, or their APIs are currently published. Never tell the author a version doesn't exist, is wrong, or should be downgraded based on your own knowledge — and never claim a library feature or API is unavailable because you assume the project uses an older major version. Raise a version-related finding only when the diff or checked-out repo contains concrete contradicting evidence (e.g., the manifest/lockfile pins a different version, or the referenced symbol is absent from the dependency's actual source on disk).
 
 ## Writing Style