@doist/doistbot-cli 1.0.5 → 1.0.6

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

@@ -1,8 +1,14 @@
 import { logger } from '../../core/logging.js';
-import { invokePiPrompt } from '../../core/pi.js';
+import { DEFAULT_OPENROUTER_MODELS, DEFAULT_PI_MODELS, invokePiPrompt, PI_PROVIDER_BY_DOISTBOT_PROVIDER, } from '../../core/pi.js';
 import { WORKSPACE_DIR } from '../../core/shared.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';
+const GEMINI_FLASH_SUMMARY_MODEL_BY_PI_PROVIDER = {
+    google: 'gemini-3-flash-preview',
+    openrouter: 'google/gemini-3-flash-preview',
+};
 const DIFF_SIDE = {
     LEFT: 'LEFT',
     RIGHT: 'RIGHT',
@@ -10,53 +16,194 @@ const DIFF_SIDE = {
 function getWorkspaceDir() {
     return WORKSPACE_DIR;
 }
-export async function requestReviewSummary({ credential, prompt, workspaceDir, }) {
+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;
+    }
+    const piProviderId = resolvedCredential.piProviderId ?? 'google';
+    const modelName = GEMINI_FLASH_SUMMARY_MODEL_BY_PI_PROVIDER[piProviderId] ??
+        GEMINI_FLASH_SUMMARY_MODEL_BY_PI_PROVIDER.google;
+    return {
+        provider: 'gemini',
+        credential,
+        modelName,
+    };
+}
+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, }) {
     try {
         const resolvedCredential = resolveReviewProviderCredential(credential);
         if (!resolvedCredential) {
-            return null;
+            return failedReviewSummaryRequest({ reason: 'missing_credential' });
         }
+        const resolvedModelName = modelName ?? resolvedCredential.modelName;
+        const logModelName = getReviewSummaryModelNameForLog({
+            provider,
+            piProviderId: resolvedCredential.piProviderId,
+            modelName: resolvedModelName,
+        });
+        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 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;
+        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,
+            });
+        }
+        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 ["gemini", "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 = ['gemini', '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();
+}