@doist/doistbot-cli 1.0.5 → 1.0.7

package/dist/actions/auth.js

@@ -1,4 +1,5 @@
-import { deleteOpenRouterApiKey, getAuthStatus, loginOpenAICodex, logoutOpenAICodex, saveOpenRouterApiKey, } from '../auth.js';
+import chalk from 'chalk';
+import { deleteGeminiApiKey, deleteOpenRouterApiKey, getAuthStatus, loginOpenAICodex, logoutOpenAICodex, saveGeminiApiKey, saveOpenRouterApiKey, } from '../auth.js';
 import { getEnvApiKeys } from '../env.js';
 import { FILE_STORE_PATH } from '../file-store.js';
 import { promptHiddenInput, promptMultiSelect } from '../input.js';
@@ -10,12 +11,23 @@ const AUTH_LOGOUT_PROVIDER_CONFIGS = [
             await logoutOpenAICodex();
             return '✓ OpenAI stored auth cleared.';
         },
-        envWarning: (env) => getEnvApiKeys(env).openai
-            ? 'OpenAI is still configured from an environment variable.'
-            : undefined,
-        name: 'OpenAI Codex',
+        envWarning: () => undefined,
+        name: 'OpenAI',
         value: 'openai',
     },
+    {
+        clear: async ({ deleteGeminiApiKey }) => {
+            const deleted = await deleteGeminiApiKey();
+            return deleted
+                ? '✓ Gemini stored API key cleared.'
+                : 'Gemini had no stored API key to clear.';
+        },
+        envWarning: (env) => getEnvApiKeys(env).gemini
+            ? 'Gemini is still configured from GEMINI_API_KEY.'
+            : undefined,
+        name: 'Gemini',
+        value: 'gemini',
+    },
     {
         clear: async ({ deleteOpenRouterApiKey }) => {
             const deleted = await deleteOpenRouterApiKey();
@@ -32,12 +44,25 @@ const AUTH_LOGOUT_PROVIDER_CONFIGS = [
 ];
 const AUTH_LOGOUT_PROVIDERS = AUTH_LOGOUT_PROVIDER_CONFIGS.map(({ value }) => value);
 export const AUTH_LOGOUT_PROVIDER_USAGE = `${AUTH_LOGOUT_PROVIDERS.join('|')}|all`;
+const OPTIONAL_LABEL = '(optional)';
+const SKIP_INSTRUCTION = 'press Enter to skip';
+const API_KEY_PROMPT = 'Paste your API Key: ';
+function highlightOptionalText(value) {
+    return chalk.bold.yellow(value);
+}
+function formatOptionalLabel() {
+    return highlightOptionalText(OPTIONAL_LABEL);
+}
+function formatSkipInstruction() {
+    return highlightOptionalText(SKIP_INSTRUCTION);
+}
 export async function runAuthSetup(dependencies = {}) {
     const deps = {
         getAuthStatus,
         isInteractive: process.stdin.isTTY === true,
         loginOpenAICodex,
         promptHiddenInput,
+        saveGeminiApiKey,
         saveOpenRouterApiKey,
         writeLine,
         ...dependencies,
@@ -46,7 +71,7 @@ export async function runAuthSetup(dependencies = {}) {
     deps.writeLine('1. OpenAI Codex');
     deps.writeLine();
     if (status.openai.configured) {
-        deps.writeLine(formatOpenAIConfiguredMessage(status.openai.source));
+        deps.writeLine('✓ OpenAI already configured (pi-auth).');
     }
     else {
         if (!deps.isInteractive) {
@@ -57,7 +82,40 @@ export async function runAuthSetup(dependencies = {}) {
         deps.writeLine('✓ OpenAI configured.');
     }
     deps.writeLine();
-    deps.writeLine('2. OpenRouter API key');
+    deps.writeLine(`2. Gemini API key ${formatOptionalLabel()}`);
+    deps.writeLine();
+    if (status.gemini.source === 'env') {
+        deps.writeLine('✓ Gemini already configured from GEMINI_API_KEY.');
+    }
+    else if (status.gemini.source === 'keychain') {
+        deps.writeLine(`✓ Gemini already configured in the ${getSecureStoreLabel()}.`);
+    }
+    else if (status.gemini.source === 'file') {
+        deps.writeLine(`✓ Gemini already configured (${FILE_STORE_PATH}).`);
+    }
+    else {
+        if (!deps.isInteractive) {
+            deps.writeLine('Gemini not configured. Skipping optional Gemini provider.');
+        }
+        else {
+            deps.writeLine(`Doistbot can use Gemini via Google Vertex. Paste a Gemini API key, or ${formatSkipInstruction()}.`);
+            const geminiApiKey = (await deps.promptHiddenInput(API_KEY_PROMPT)).trim();
+            if (!geminiApiKey) {
+                deps.writeLine();
+                deps.writeLine('Gemini skipped. You can add it later with `doistbot auth`.');
+            }
+            else {
+                const backend = await deps.saveGeminiApiKey(geminiApiKey);
+                deps.writeLine();
+                if (backend === 'file') {
+                    deps.writeLine(`Note: ${getSecureStoreLabel()} unavailable; key stored in ${FILE_STORE_PATH} with 0600 permissions.`);
+                }
+                deps.writeLine('✓ Gemini configured.');
+            }
+        }
+    }
+    deps.writeLine();
+    deps.writeLine(`3. OpenRouter API key ${formatOptionalLabel()}`);
     deps.writeLine();
     if (status.openrouter.source === 'env') {
         deps.writeLine('✓ OpenRouter already configured from OPENROUTER_API_KEY.');
@@ -72,10 +130,17 @@ export async function runAuthSetup(dependencies = {}) {
         return;
     }
     if (!deps.isInteractive) {
-        throw new Error('Cannot prompt for OpenRouter API key in non-interactive mode. Set OPENROUTER_API_KEY instead.');
+        deps.writeLine('OpenRouter not configured. Skipping optional OpenRouter provider.');
+        return;
+    }
+    deps.writeLine(`Doistbot can use OpenRouter for DeepSeek, Z.ai, and other open models. Paste an OpenRouter API key, or ${formatSkipInstruction()}.`);
+    const openRouterApiKey = (await deps.promptHiddenInput(API_KEY_PROMPT)).trim();
+    if (!openRouterApiKey) {
+        deps.writeLine();
+        deps.writeLine('OpenRouter skipped. You can add it later with `doistbot auth`.');
+        return;
     }
-    deps.writeLine('Doistbot uses OpenRouter for interacting with Gemini. Please create an OpenRouter API key at https://openrouter.ai/keys and paste it here. (Use your Work Perk for it)');
-    const backend = await deps.saveOpenRouterApiKey(await deps.promptHiddenInput('OpenRouter API key: '));
+    const backend = await deps.saveOpenRouterApiKey(openRouterApiKey);
     deps.writeLine();
     if (backend === 'file') {
         deps.writeLine(`Note: ${getSecureStoreLabel()} unavailable; key stored in ${FILE_STORE_PATH} with 0600 permissions.`);
@@ -85,10 +150,12 @@ export async function runAuthSetup(dependencies = {}) {
 export async function runAuthStatus() {
     const status = await getAuthStatus();
     writeLine(`OpenAI: ${status.openai.configured ? `configured (${status.openai.source ?? 'unknown'})` : 'not configured'}`);
-    writeLine(`OpenRouter: ${status.openrouter.configured ? `configured (${status.openrouter.source ?? 'unknown'})` : 'not configured'}`);
+    writeLine(`Gemini ${formatOptionalLabel()}: ${status.gemini.configured ? `configured (${status.gemini.source ?? 'unknown'})` : 'not configured'}`);
+    writeLine(`OpenRouter ${formatOptionalLabel()}: ${status.openrouter.configured ? `configured (${status.openrouter.source ?? 'unknown'})` : 'not configured'}`);
 }
 export async function runAuthLogout(target, dependencies = {}) {
     const deps = {
+        deleteGeminiApiKey,
         deleteOpenRouterApiKey,
         env: process.env,
         isInteractive: process.stdin.isTTY === true,
@@ -142,16 +209,3 @@ async function promptLogoutProviderSelection() {
         choices: AUTH_LOGOUT_PROVIDER_CONFIGS.map(({ name, value }) => ({ name, value })),
     });
 }
-function formatOpenAIConfiguredMessage(source) {
-    switch (source) {
-        case 'pi-auth':
-            return '✓ OpenAI already configured (pi-auth).';
-        case 'env':
-            return '✓ OpenAI already configured from the environment.';
-        case 'keychain':
-            return '✓ OpenAI already configured (keychain).';
-        case 'file':
-        case undefined:
-            return '✓ OpenAI already configured.';
-    }
-}

package/dist/actions/doctor.js

@@ -1,25 +1,32 @@
 import { getAuthStatus } from '../auth.js';
+import { formatMissingRequiredCliAuthProviders, getMissingRequiredCliAuthProviders, } from '../config.js';
 import { checkGit, checkPiDependency, checkRepository, checkSandboxBuild } from '../runtime.js';
 import { renderDiagnosticCheck } from '../terminal.js';
 export function getConfiguredProviders({ status, }) {
     return [
-        status.openai.configured
-            ? `OpenAI (${status.openai.source === 'pi-auth'
-                ? 'pi-auth record found; validated during review'
-                : (status.openai.source ?? 'configured')})`
+        status.openai.configured ? `OpenAI (${status.openai.source ?? 'configured'})` : undefined,
+        status.gemini.configured
+            ? `Gemini optional (${status.gemini.source ?? 'configured'})`
             : undefined,
         status.openrouter.configured
-            ? `OpenRouter (${status.openrouter.source ?? 'configured'})`
+            ? `OpenRouter optional (${status.openrouter.source ?? 'configured'})`
             : undefined,
     ].filter((provider) => provider !== undefined);
 }
+export function getMissingRequiredProviders({ status, }) {
+    return getMissingRequiredCliAuthProviders(status);
+}
 export async function checkAuth({ env = process.env, getStatus = getAuthStatus, } = {}) {
     const status = await getStatus({ env });
     const configured = getConfiguredProviders({ status });
-    if (configured.length > 0) {
+    const missingRequiredProviders = getMissingRequiredProviders({ status });
+    if (missingRequiredProviders.length === 0) {
         return { ok: true, message: `${configured.join(', ')} configured` };
     }
-    return { ok: false, message: 'run `doistbot auth`' };
+    return {
+        ok: false,
+        message: formatMissingRequiredCliAuthProviders(missingRequiredProviders),
+    };
 }
 export async function runDoctor() {
     await renderDiagnosticCheck('git', checkGit);

package/dist/actions/review.js

@@ -1,11 +1,13 @@
-import { getApiKeys } from '../config.js';
+import { formatMissingRequiredCliAuthProviders, getApiKeys, getCliReviewRouting, getMissingRequiredCliReviewAuthProviders, } from '../config.js';
 import { getRepositoryRoot, loadSandboxFormatModule, loadSandboxReviewModule } from '../runtime.js';
 import { formatReviewProgress, renderAlert, renderMarkdown, withSpinner, writeLine, } from '../terminal.js';
 const LOCAL_REVIEW_SOURCE_STAGED = 'staged';
 const JSON_SCHEMA_VERSION = 1;
 const PROVIDER_DISPLAY_NAMES = {
+    deepseek: 'DeepSeek',
     gemini: 'Gemini',
-    openai: 'OpenAI Codex',
+    zai: 'Z.ai',
+    openai: 'OpenAI',
 };
 function stripProviderFailurePrefix(error) {
     return error
@@ -17,8 +19,11 @@ function getReadableProviderFailure(failure) {
     const error = stripProviderFailurePrefix(failure.error);
     const normalized = error.toLowerCase();
     if (failure.model === 'openai' &&
-        (normalized.includes('no api key found for openai-codex') ||
-            normalized.includes('use /login'))) {
+        (normalized.includes('no api key found for openai') ||
+            normalized.includes('no api key found for openai-codex') ||
+            normalized.includes('use /login') ||
+            normalized.includes('invalid api key') ||
+            normalized.includes('incorrect api key'))) {
         return 'OpenAI Codex is not authenticated. Run `doistbot auth` to reconnect OpenAI.';
     }
     if (failure.model === 'gemini' &&
@@ -27,15 +32,16 @@ function getReadableProviderFailure(failure) {
             normalized.includes('quota') ||
             normalized.includes('rate-limit') ||
             normalized.includes('rate limit'))) {
-        return 'Gemini via OpenRouter is rate-limited or out of quota. Check your OpenRouter credits, provider routing, or wait for quota to reset.';
+        return 'Gemini is rate-limited or out of quota. Check your Google Gemini quota or wait for quota to reset.';
     }
     if (failure.model === 'gemini' &&
         (normalized.includes('api_key_invalid') ||
             normalized.includes('api key not valid') ||
             normalized.includes('invalid_argument') ||
             normalized.includes('invalid api key') ||
-            normalized.includes('no api key found for openrouter'))) {
-        return 'OpenRouter API key is invalid or missing. Run `doistbot auth` and paste a valid key from https://openrouter.ai/keys.';
+            normalized.includes('no api key found for google') ||
+            normalized.includes('no api key found for gemini'))) {
+        return 'Gemini API key is invalid or missing. Run `doistbot auth` and paste a valid Gemini key.';
     }
     const firstLine = error
         .split(/\r?\n/)
@@ -187,19 +193,69 @@ function formatReviewForJson(result) {
         providerFailures: getReadableProviderFailureEntries(result.reviewResult.providerFailures),
     };
 }
-async function runLocalReviewForCli({ source, onProgress, }) {
+async function getReviewAuthCheck() {
+    const apiKeys = await getApiKeys();
+    return {
+        apiKeys,
+        missingProviders: getMissingRequiredCliReviewAuthProviders(apiKeys),
+    };
+}
+function getMissingAuthProviderFailures(missingProviders) {
+    const failures = [];
+    if (missingProviders.includes('OpenAI')) {
+        failures.push({
+            model: 'openai',
+            message: 'OpenAI not configured; run `doistbot auth`',
+        });
+    }
+    return failures;
+}
+function formatMissingAuthForJson({ source, missingProviders, }) {
+    return {
+        schemaVersion: JSON_SCHEMA_VERSION,
+        status: 'unverified',
+        verified: false,
+        unverifiedReason: 'missing_auth',
+        reviewSource: source,
+        repository: {
+            owner: 'unknown',
+            repo: 'unknown',
+            branch: 'unknown',
+            baseBranch: 'unknown',
+        },
+        review: {
+            count: 0,
+            findings: [],
+        },
+        providerFailures: getMissingAuthProviderFailures(missingProviders),
+    };
+}
+async function runLocalReviewForCli({ source, apiKeys, onProgress, }) {
     const reviewModule = await loadSandboxReviewModule();
     return await reviewModule.runLocalReview({
         workspaceDir: getRepositoryRoot(),
         source,
-        apiKeys: await getApiKeys(),
+        apiKeys,
+        ...getCliReviewRouting(apiKeys),
         suppressLogs: true,
         onProgress,
     });
 }
 export async function runReview({ source, json = false } = { source: 'base' }) {
+    const authCheck = await getReviewAuthCheck();
+    if (authCheck.missingProviders.length > 0) {
+        if (json) {
+            writeLine(JSON.stringify(formatMissingAuthForJson({
+                source,
+                missingProviders: authCheck.missingProviders,
+            }), null, 2));
+            process.exitCode = 1;
+            return;
+        }
+        throw new Error(formatMissingRequiredCliAuthProviders(authCheck.missingProviders));
+    }
     if (json) {
-        const result = await runLocalReviewForCli({ source });
+        const result = await runLocalReviewForCli({ source, apiKeys: authCheck.apiKeys });
         const output = formatReviewForJson(result);
         writeLine(JSON.stringify(output, null, 2));
         if (output.status === 'unverified') {
@@ -211,6 +267,7 @@ export async function runReview({ source, json = false } = { source: 'base' }) {
         ? 'Reviewing staged changes...'
         : 'Reviewing local changes...', async (status) => await runLocalReviewForCli({
         source,
+        apiKeys: authCheck.apiKeys,
         onProgress: status.enabled
             ? (event) => status.update(formatReviewProgress(event))
             : undefined,

package/dist/auth.js

@@ -5,14 +5,18 @@ import { getEnvApiKeys } from './env.js';
 import { createFileStore } from './file-store.js';
 import { promptInput } from './input.js';
 import { createCompositeStore, createKeyringStore, SecureStoreUnavailableError, } from './secure-store.js';
+const GEMINI_ACCOUNT_NAME = 'gemini-api-key';
 const OPENROUTER_ACCOUNT_NAME = 'openrouter-api-key';
+export function createGeminiKeyStore() {
+    return createCompositeStore(createKeyringStore(GEMINI_ACCOUNT_NAME), createFileStore(GEMINI_ACCOUNT_NAME));
+}
 export function createOpenRouterKeyStore() {
     return createCompositeStore(createKeyringStore(OPENROUTER_ACCOUNT_NAME), createFileStore(OPENROUTER_ACCOUNT_NAME));
 }
 export const OPENAI_CODEX_PROVIDER_ID = 'openai-codex';
 export const PI_AUTH_API_KEY = `pi-auth://${OPENAI_CODEX_PROVIDER_ID}`;
 export async function createPiAuthStorage() {
-    const { AuthStorage } = await import('@mariozechner/pi-coding-agent');
+    const { AuthStorage } = await import('@earendil-works/pi-coding-agent');
     return AuthStorage.create(path.join(homedir(), '.pi', 'agent', 'auth.json'));
 }
 export function getBrowserOpenCommand(platform, url) {
@@ -30,12 +34,25 @@ export async function hasOpenAICodexAuth(storage) {
 }
 export async function loginOpenAICodex(storage) {
     const resolvedStorage = storage ?? (await createPiAuthStorage());
-    await resolvedStorage.login(OPENAI_CODEX_PROVIDER_ID, createOpenAICodexLoginCallbacks());
+    const { loginOpenAICodex: loginInBrowser } = await import('@earendil-works/pi-ai/oauth');
+    const credentials = await loginInBrowser(createOpenAICodexBrowserLoginOptions());
+    saveOpenAICodexCredentials(resolvedStorage, credentials);
+}
+export function saveOpenAICodexCredentials(storage, credentials) {
+    storage.set(OPENAI_CODEX_PROVIDER_ID, { type: 'oauth', ...credentials });
 }
 export async function logoutOpenAICodex(storage) {
     const resolvedStorage = storage ?? (await createPiAuthStorage());
     resolvedStorage.logout(OPENAI_CODEX_PROVIDER_ID);
 }
+export async function readStoredGeminiApiKey(store = createGeminiKeyStore()) {
+    const result = await store.getSecret();
+    const trimmed = result.value?.trim();
+    return trimmed ? { value: trimmed, backend: result.backend } : { value: undefined };
+}
+export async function getStoredGeminiApiKey(store = createGeminiKeyStore()) {
+    return (await readStoredGeminiApiKey(store)).value;
+}
 export async function readStoredOpenRouterApiKey(store = createOpenRouterKeyStore()) {
     const result = await store.getSecret();
     const trimmed = result.value?.trim();
@@ -44,6 +61,21 @@ export async function readStoredOpenRouterApiKey(store = createOpenRouterKeyStor
 export async function getStoredOpenRouterApiKey(store = createOpenRouterKeyStore()) {
     return (await readStoredOpenRouterApiKey(store)).value;
 }
+export async function saveGeminiApiKey(apiKey, store = createGeminiKeyStore()) {
+    const normalized = apiKey.trim();
+    if (!normalized) {
+        throw new Error('Gemini API key cannot be empty');
+    }
+    try {
+        return await store.setSecret(normalized);
+    }
+    catch (error) {
+        if (error instanceof SecureStoreUnavailableError) {
+            throw new SecureStoreUnavailableError(`${error.message} Set GEMINI_API_KEY in your environment instead.`);
+        }
+        throw error;
+    }
+}
 export async function saveOpenRouterApiKey(apiKey, store = createOpenRouterKeyStore()) {
     const normalized = apiKey.trim();
     if (!normalized) {
@@ -62,8 +94,14 @@ export async function saveOpenRouterApiKey(apiKey, store = createOpenRouterKeySt
 export async function deleteOpenRouterApiKey(store = createOpenRouterKeyStore()) {
     return await store.deleteSecret();
 }
-export async function getAuthStatus({ env = process.env, storage, openRouterStore = createOpenRouterKeyStore(), } = {}) {
+export async function deleteGeminiApiKey(store = createGeminiKeyStore()) {
+    return await store.deleteSecret();
+}
+export async function getAuthStatus({ env = process.env, storage, geminiStore = createGeminiKeyStore(), openRouterStore = createOpenRouterKeyStore(), } = {}) {
     const envApiKeys = getEnvApiKeys(env);
+    const geminiStored = envApiKeys.gemini
+        ? { value: undefined }
+        : await readStoredGeminiApiKey(geminiStore).catch(() => ({ value: undefined }));
     const openRouterStored = envApiKeys.openrouter
         ? { value: undefined }
         : await readStoredOpenRouterApiKey(openRouterStore).catch(() => ({ value: undefined }));
@@ -71,9 +109,16 @@ export async function getAuthStatus({ env = process.env, storage, openRouterStor
     return {
         openai: openAICodexAuthConfigured
             ? { configured: true, source: 'pi-auth' }
+            : { configured: false, source: undefined },
+        gemini: envApiKeys.gemini
+            ? { configured: true, source: 'env' }
             : {
-                configured: envApiKeys.openai !== undefined,
-                source: envApiKeys.openai !== undefined ? 'env' : undefined,
+                configured: geminiStored.value !== undefined,
+                source: geminiStored.value !== undefined
+                    ? geminiStored.backend === 'file'
+                        ? 'file'
+                        : 'keychain'
+                    : undefined,
             },
         openrouter: envApiKeys.openrouter
             ? { configured: true, source: 'env' }
@@ -87,7 +132,7 @@ export async function getAuthStatus({ env = process.env, storage, openRouterStor
             },
     };
 }
-function createOpenAICodexLoginCallbacks() {
+function createOpenAICodexBrowserLoginOptions() {
     return {
         onAuth: (info) => {
             openUrlInBrowser(info.url);

package/dist/config.js

@@ -1,22 +1,94 @@
-import { getStoredOpenRouterApiKey, hasOpenAICodexAuth, PI_AUTH_API_KEY } from './auth.js';
+import { getStoredGeminiApiKey, getStoredOpenRouterApiKey, hasOpenAICodexAuth, PI_AUTH_API_KEY, } from './auth.js';
 import { getEnvApiKeys } from './env.js';
+const REQUIRED_CLI_AUTH_PROVIDERS = [{ provider: 'openai', label: 'OpenAI' }];
+const ALL_REVIEW_FOCUSES = [
+    'general',
+    'quality',
+    'efficiency',
+    'tests',
+    'standards',
+];
+const OPENROUTER_REVIEW_MODELS = ['deepseek', 'zai'];
+const CLI_GEMINI_REVIEW_MODEL = 'gemini-3.5-flash';
+function createCliGeminiCredential(apiKey) {
+    return {
+        apiKey,
+        modelName: CLI_GEMINI_REVIEW_MODEL,
+    };
+}
+function createCliGeminiSummaryModel(credential) {
+    if (!credential) {
+        return undefined;
+    }
+    return {
+        provider: 'gemini',
+        credential,
+        modelName: CLI_GEMINI_REVIEW_MODEL,
+    };
+}
 export async function getApiKeys(env = process.env, auth = {
+    getStoredGeminiApiKey,
     getStoredOpenRouterApiKey,
     hasOpenAICodexAuth,
 }) {
     const envApiKeys = getEnvApiKeys(env);
+    const storedGeminiApiKey = envApiKeys.gemini
+        ? undefined
+        : await auth.getStoredGeminiApiKey().catch(() => undefined);
     const storedOpenRouterApiKey = envApiKeys.openrouter
         ? undefined
         : await auth.getStoredOpenRouterApiKey().catch(() => undefined);
     const openAICodexAuthConfigured = await auth.hasOpenAICodexAuth();
     const openRouterApiKey = envApiKeys.openrouter || storedOpenRouterApiKey;
     const apiKeys = {};
+    const geminiApiKey = envApiKeys.gemini || storedGeminiApiKey;
+    if (geminiApiKey) {
+        apiKeys.gemini = createCliGeminiCredential(geminiApiKey);
+    }
     if (openRouterApiKey) {
-        apiKeys.gemini = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
+        apiKeys.deepseek = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
+        apiKeys.zai = { apiKey: openRouterApiKey, piProviderId: 'openrouter' };
     }
-    const openAIKey = openAICodexAuthConfigured ? PI_AUTH_API_KEY : envApiKeys.openai;
-    if (openAIKey) {
-        apiKeys.openai = openAIKey;
+    if (openAICodexAuthConfigured) {
+        apiKeys.openai = PI_AUTH_API_KEY;
     }
     return apiKeys;
 }
+export function getMissingRequiredCliAuthProviders(status) {
+    return REQUIRED_CLI_AUTH_PROVIDERS.filter(({ provider }) => !status[provider].configured).map(({ label }) => label);
+}
+export function getMissingRequiredCliReviewAuthProviders(apiKeys) {
+    return REQUIRED_CLI_AUTH_PROVIDERS.filter(({ provider }) => {
+        switch (provider) {
+            case 'openai':
+                return !apiKeys.openai;
+        }
+        return false;
+    }).map(({ label }) => label);
+}
+export function formatMissingRequiredCliAuthProviders(missingProviders) {
+    return `${missingProviders.join(' and ')} not configured; run \`doistbot auth\``;
+}
+export function getCliReviewRouting(apiKeys) {
+    const hasGemini = Boolean(apiKeys.gemini);
+    const hasOpenRouter = Boolean(apiKeys.deepseek && apiKeys.zai);
+    if (hasGemini && hasOpenRouter) {
+        return {
+            reviewModelsEnabled: ['openai', ...OPENROUTER_REVIEW_MODELS],
+            geminiFallbackFocuses: ALL_REVIEW_FOCUSES,
+        };
+    }
+    const focusModels = [
+        'openai',
+        ...(hasGemini ? ['gemini'] : []),
+        ...(hasOpenRouter ? OPENROUTER_REVIEW_MODELS : []),
+    ];
+    return {
+        reviewModelsEnabled: focusModels,
+        reviewModelsByFocus: Object.fromEntries(ALL_REVIEW_FOCUSES.map((focus) => [focus, focusModels])),
+        geminiFallbackFocuses: [],
+        ...(hasGemini && !hasOpenRouter
+            ? { reviewSummaryModel: createCliGeminiSummaryModel(apiKeys.gemini) }
+            : {}),
+    };
+}

package/dist/env.js

@@ -3,6 +3,7 @@ function getEnvValue(value) {
 }
 export function getEnvApiKeys(env = process.env) {
     return {
+        gemini: getEnvValue(env.GEMINI_API_KEY),
         openai: getEnvValue(env.OPENAI_KEY) || getEnvValue(env.OPENAI_API_KEY),
         openrouter: getEnvValue(env.OPENROUTER_API_KEY),
     };

package/dist/runtime.js

@@ -93,7 +93,7 @@ export function checkSandboxBuild() {
 }
 export function checkPiDependency() {
     try {
-        import.meta.resolve('@mariozechner/pi-coding-agent');
+        import.meta.resolve('@earendil-works/pi-coding-agent');
         return { ok: true, message: 'Pi coding agent is installed' };
     }
     catch {

package/dist/terminal.js

@@ -114,7 +114,9 @@ export async function withSpinner(message, task, terminalConfig = getDefaultTerm
     }
 }
 const PROVIDER_DISPLAY_NAMES = {
+    deepseek: 'DeepSeek',
     gemini: 'Gemini',
+    zai: 'Z.ai',
     openai: 'OpenAI',
 };
 function pluralizeChangedFiles(fileCount) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/doistbot-cli",
-    "version": "1.0.5",
+    "version": "1.0.7",
     "description": "Local self-review CLI for Doistbot",
     "type": "module",
     "main": "dist/index.js",
@@ -42,8 +42,8 @@
     "dependencies": {
         "@inquirer/checkbox": "5.2.1",
         "@inquirer/password": "5.1.1",
-        "@mariozechner/pi-ai": "0.73.1",
-        "@mariozechner/pi-coding-agent": "0.73.1",
+        "@earendil-works/pi-ai": "0.79.6",
+        "@earendil-works/pi-coding-agent": "0.79.6",
         "@napi-rs/keyring": "1.3.0",
         "ajv": "8.20.0",
         "chalk": "4.1.2",
@@ -53,6 +53,6 @@
         "yocto-spinner": "1.2.0"
     },
     "devDependencies": {
-        "vitest": "4.1.8"
+        "vitest": "4.1.9"
     }
 }

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();
+}