@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/dist/actions/auth.js

@@ -0,0 +1,225 @@
+import chalk from 'chalk';
+import { createPiAuthRuntime, 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';
+import { getSecureStoreLabel } from '../secure-store.js';
+import { writeLine } from '../terminal.js';
+const AUTH_LOGOUT_PROVIDER_CONFIGS = [
+    {
+        clear: async ({ logoutOpenAICodex }) => {
+            await logoutOpenAICodex();
+            return '✓ OpenAI stored auth cleared.';
+        },
+        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();
+            return deleted
+                ? '✓ OpenRouter stored API key cleared.'
+                : 'OpenRouter had no stored API key to clear.';
+        },
+        envWarning: (env) => getEnvApiKeys(env).openrouter
+            ? 'OpenRouter is still configured from OPENROUTER_API_KEY.'
+            : undefined,
+        name: 'OpenRouter',
+        value: 'openrouter',
+    },
+];
+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 = {
+        createPiAuthRuntime,
+        getAuthStatus,
+        isInteractive: process.stdin.isTTY === true,
+        loginOpenAICodex,
+        promptHiddenInput,
+        saveGeminiApiKey,
+        saveOpenRouterApiKey,
+        writeLine,
+        ...dependencies,
+    };
+    const runtime = await deps.createPiAuthRuntime();
+    const status = await deps.getAuthStatus({ runtime });
+    deps.writeLine('1. OpenAI Codex');
+    deps.writeLine();
+    if (status.openai.configured && !status.openai.refreshFailed) {
+        deps.writeLine('✓ OpenAI already configured (pi-auth).');
+    }
+    else {
+        if (!deps.isInteractive) {
+            throw new Error('Cannot configure OpenAI Codex auth in non-interactive mode.');
+        }
+        if (status.openai.refreshFailed) {
+            deps.writeLine('OpenAI session could not be refreshed (expired, revoked, or offline). Reconnecting.');
+        }
+        await deps.loginOpenAICodex(runtime);
+        deps.writeLine();
+        deps.writeLine('✓ OpenAI configured.');
+    }
+    deps.writeLine();
+    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.');
+        return;
+    }
+    if (status.openrouter.source === 'keychain') {
+        deps.writeLine(`✓ OpenRouter already configured in the ${getSecureStoreLabel()}.`);
+        return;
+    }
+    if (status.openrouter.source === 'file') {
+        deps.writeLine(`✓ OpenRouter already configured (${FILE_STORE_PATH}).`);
+        return;
+    }
+    if (!deps.isInteractive) {
+        deps.writeLine('OpenRouter not configured. Skipping optional OpenRouter provider.');
+        return;
+    }
+    deps.writeLine(`Doistbot can use OpenRouter for DeepSeek, Grok, 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;
+    }
+    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.`);
+    }
+    deps.writeLine('✓ OpenRouter configured.');
+}
+export async function runAuthStatus() {
+    const status = await getAuthStatus();
+    writeLine(`OpenAI: ${formatOpenAIStatus(status.openai)}`);
+    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'}`);
+}
+function formatOpenAIStatus(status) {
+    if (!status.configured) {
+        return 'not configured';
+    }
+    const base = `configured (${status.source ?? 'unknown'})`;
+    return status.refreshFailed
+        ? `${base} — session could not be refreshed; check your connection or run \`doistbot auth login\``
+        : base;
+}
+export async function runAuthLogout(target, dependencies = {}) {
+    const deps = {
+        deleteGeminiApiKey,
+        deleteOpenRouterApiKey,
+        env: process.env,
+        isInteractive: process.stdin.isTTY === true,
+        logoutOpenAICodex,
+        promptProviderSelection: promptLogoutProviderSelection,
+        writeLine,
+        ...dependencies,
+    };
+    const providers = await resolveLogoutProviders(target, deps);
+    const providerConfigs = providers.map(getAuthLogoutProviderConfig);
+    const clearMessages = await Promise.all(providerConfigs.map((config) => config.clear(deps)));
+    for (const message of clearMessages) {
+        deps.writeLine(message);
+    }
+    for (const config of providerConfigs) {
+        const warning = config.envWarning(deps.env);
+        if (warning) {
+            deps.writeLine(warning);
+        }
+    }
+}
+async function resolveLogoutProviders(target, dependencies) {
+    if (target === undefined) {
+        if (!dependencies.isInteractive) {
+            throw new Error(`Provider required in non-interactive mode. Use \`doistbot auth logout ${AUTH_LOGOUT_PROVIDER_USAGE}\`.`);
+        }
+        return await dependencies.promptProviderSelection();
+    }
+    const normalized = target.toLowerCase();
+    if (normalized === 'all') {
+        return [...AUTH_LOGOUT_PROVIDERS];
+    }
+    if (isAuthLogoutProvider(normalized)) {
+        return [normalized];
+    }
+    throw new Error(`Usage: doistbot auth logout [${AUTH_LOGOUT_PROVIDER_USAGE}]`);
+}
+function isAuthLogoutProvider(value) {
+    return AUTH_LOGOUT_PROVIDERS.includes(value);
+}
+function getAuthLogoutProviderConfig(provider) {
+    const config = AUTH_LOGOUT_PROVIDER_CONFIGS.find(({ value }) => value === provider);
+    if (!config) {
+        throw new Error(`Unsupported auth logout provider: ${provider}`);
+    }
+    return config;
+}
+async function promptLogoutProviderSelection() {
+    return await promptMultiSelect({
+        message: 'Select providers to log out:',
+        choices: AUTH_LOGOUT_PROVIDER_CONFIGS.map(({ name, value }) => ({ name, value })),
+    });
+}

package/dist/actions/doctor.js

@@ -0,0 +1,39 @@
+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 && !status.openai.refreshFailed
+            ? `OpenAI (${status.openai.source ?? 'configured'})`
+            : undefined,
+        status.gemini.configured
+            ? `Gemini optional (${status.gemini.source ?? 'configured'})`
+            : undefined,
+        status.openrouter.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 });
+    const missingRequiredProviders = getMissingRequiredProviders({ status });
+    if (missingRequiredProviders.length === 0) {
+        return { ok: true, message: `${configured.join(', ')} configured` };
+    }
+    return {
+        ok: false,
+        message: formatMissingRequiredCliAuthProviders(missingRequiredProviders),
+    };
+}
+export async function runDoctor() {
+    await renderDiagnosticCheck('git', checkGit);
+    await renderDiagnosticCheck('repository', checkRepository);
+    await renderDiagnosticCheck('pi', checkPiDependency);
+    await renderDiagnosticCheck('sandbox build', checkSandboxBuild);
+    await renderDiagnosticCheck('auth', checkAuth);
+}

package/dist/actions/review-usage.js

@@ -0,0 +1,25 @@
+const REVIEW_USAGE_COMMANDS = [
+    'doistbot review [--base <ref>] [--models <models>]',
+    'doistbot review staged [--models <models>]',
+    'db review [--base <ref>] [--models <models>]',
+    'db review staged [--models <models>]',
+];
+const REVIEW_SETUP_COMMANDS = [
+    'doistbot review',
+    'doistbot review staged',
+    'db review',
+    'db review staged',
+];
+export function formatReviewUsage() {
+    return `Usage: ${formatCommandList(REVIEW_USAGE_COMMANDS)}`;
+}
+export function formatSetupCompleteMessage() {
+    return `Setup complete. Run ${formatCommandList(REVIEW_SETUP_COMMANDS)} from a git repository.`;
+}
+function formatCommandList(commands) {
+    const quotedCommands = commands.map((command) => `\`${command}\``);
+    if (quotedCommands.length <= 2) {
+        return quotedCommands.join(' or ');
+    }
+    return `${quotedCommands.slice(0, -1).join(', ')}, or ${quotedCommands.at(-1)}`;
+}

package/dist/actions/review.js

@@ -0,0 +1,311 @@
+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',
+    grok: 'Grok',
+    zai: 'Z.ai',
+    openai: 'OpenAI',
+};
+function stripProviderFailurePrefix(error) {
+    return error
+        .replace(/^Pi\s+\w+\s+request failed:\s*/i, '')
+        .replace(/^Pi\s+\w+\s+request timed out after\s*/i, 'Timed out after ')
+        .trim();
+}
+function getReadableProviderFailure(failure) {
+    const error = stripProviderFailurePrefix(failure.error);
+    const normalized = error.toLowerCase();
+    if (failure.model === 'openai' &&
+        (normalized.includes('no api key found for openai') ||
+            normalized.includes('no api key found for openai-codex') ||
+            normalized.includes('no api key for provider') ||
+            normalized.includes('use /login') ||
+            normalized.includes('invalid api key') ||
+            normalized.includes('incorrect api key') ||
+            normalized.includes('refresh_token_invalidated') ||
+            normalized.includes('unauthorized') ||
+            /\b401\b/.test(normalized))) {
+        return 'OpenAI Codex is not authenticated. Run `doistbot auth login` to reconnect OpenAI.';
+    }
+    if (failure.model === 'gemini' &&
+        (normalized.includes('429') ||
+            normalized.includes('resource_exhausted') ||
+            normalized.includes('quota') ||
+            normalized.includes('rate-limit') ||
+            normalized.includes('rate limit'))) {
+        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 google') ||
+            normalized.includes('no api key found for gemini') ||
+            normalized.includes('no api key for provider'))) {
+        return 'Gemini API key is invalid or missing. Run `doistbot auth` and paste a valid Gemini key.';
+    }
+    const firstLine = error
+        .split(/\r?\n/)
+        .find((line) => line.trim())
+        ?.trim();
+    return `${PROVIDER_DISPLAY_NAMES[failure.model]} failed: ${firstLine || 'unknown error'}`;
+}
+function getReadableProviderFailureEntries(failures) {
+    const messagesByModel = new Map();
+    for (const failure of failures) {
+        if (!messagesByModel.has(failure.model)) {
+            messagesByModel.set(failure.model, getReadableProviderFailure(failure));
+        }
+    }
+    return Array.from(messagesByModel, ([model, message]) => ({ model, message }));
+}
+function getReadableProviderFailures(failures) {
+    return getReadableProviderFailureEntries(failures).map(({ message }) => message);
+}
+function formatProviderFailureMessage(failures) {
+    const messages = getReadableProviderFailures(failures);
+    if (messages.length === 0) {
+        return 'Review failed: no model returned a usable review.';
+    }
+    return `Review failed because no provider returned a usable review:\n${messages
+        .map((message) => `- ${message}`)
+        .join('\n')}`;
+}
+function formatPartialProviderFailureMessage(failures) {
+    const messages = getReadableProviderFailures(failures);
+    if (messages.length === 0) {
+        return '';
+    }
+    return `Review completed with provider warnings:\n${messages
+        .map((message) => `- ${message}`)
+        .join('\n')}`;
+}
+function handleSkippedReview(result) {
+    switch (result.reason) {
+        case 'no_diff':
+        case 'empty_diff':
+            writeLine('No local changes to review.');
+            return;
+        case 'no_models':
+            writeLine('No review models are configured. Run `doistbot doctor` for details.');
+            return;
+        case 'no_review':
+            throw new Error(formatProviderFailureMessage(result.providerFailures));
+        default:
+            writeLine(`Review skipped: ${result.reason}`);
+    }
+}
+function formatReviewOutput({ formatReviewForTerminal, review, }) {
+    return formatReviewForTerminal({ review });
+}
+function getJsonStatus(result) {
+    function mapping(statusMapping, canTrustCleanReview = statusMapping.status === 'reviewed') {
+        return { mapping: statusMapping, canTrustCleanReview };
+    }
+    if (result.reviewResult.status === 'skipped') {
+        switch (result.reviewResult.reason) {
+            case 'empty_review':
+            case 'no_models':
+            case 'no_review':
+                return mapping({
+                    status: 'unverified',
+                    verified: false,
+                    unverifiedReason: result.reviewResult.reason,
+                }, false);
+            default:
+                return mapping({
+                    status: 'skipped',
+                    verified: false,
+                    skipReason: result.reviewResult.reason,
+                }, false);
+        }
+    }
+    return mapping({ status: 'reviewed', verified: true });
+}
+function finalizeJsonStatus({ initialStatus, findingCount, providerFailureCount, }) {
+    if (initialStatus.canTrustCleanReview && providerFailureCount > 0 && findingCount === 0) {
+        return { status: 'unverified', verified: false, unverifiedReason: 'provider_failures' };
+    }
+    return initialStatus.mapping;
+}
+function getReviewForJson(result) {
+    if (result.reviewResult.status === 'reviewed') {
+        return result.reviewResult.review;
+    }
+    return { summary: '', comments: [] };
+}
+function hasLocation(finding) {
+    return typeof finding.path === 'string' && typeof finding.line === 'number';
+}
+function formatReviewJsonFinding(finding) {
+    return {
+        body: finding.body,
+        severity: finding.severity,
+        ...(hasLocation(finding)
+            ? {
+                location: {
+                    path: finding.path,
+                    line: finding.line,
+                    ...(finding.side ? { side: finding.side } : {}),
+                },
+            }
+            : {}),
+    };
+}
+function getReviewFindingsForJson(review) {
+    if (review.findings) {
+        return review.findings;
+    }
+    return review.comments.map((comment) => ({
+        body: comment.body,
+        severity: null,
+        placement: 'inline',
+        path: comment.path,
+        line: comment.line,
+        side: comment.side,
+    }));
+}
+function getReviewFindingCount(review) {
+    return getReviewFindingsForJson(review).length;
+}
+export function formatReviewForJson(result) {
+    const review = getReviewForJson(result);
+    const reviewFindings = getReviewFindingsForJson(review);
+    const findings = reviewFindings.map(formatReviewJsonFinding);
+    const statusMapping = finalizeJsonStatus({
+        initialStatus: getJsonStatus(result),
+        findingCount: findings.length,
+        providerFailureCount: result.reviewResult.providerFailures.length,
+    });
+    return {
+        schemaVersion: JSON_SCHEMA_VERSION,
+        ...statusMapping,
+        reviewSource: result.source,
+        repository: {
+            owner: result.owner,
+            repo: result.repo,
+            branch: result.branch,
+            baseBranch: result.baseBranch,
+        },
+        review: {
+            count: findings.length,
+            findings,
+        },
+        providerFailures: getReadableProviderFailureEntries(result.reviewResult.providerFailures),
+        ...(review.reviewMode ? { reviewMode: review.reviewMode } : {}),
+    };
+}
+async function getReviewAuthCheck(models) {
+    if (models !== undefined) {
+        const configuredApiKeys = await getApiKeys(undefined, undefined, models);
+        const missingModels = models.filter((model) => configuredApiKeys[model] === undefined);
+        return {
+            apiKeys: configuredApiKeys,
+            missingModels,
+            missingProviders: missingModels.map((model) => PROVIDER_DISPLAY_NAMES[model]),
+        };
+    }
+    const configuredApiKeys = await getApiKeys();
+    const missingRequiredProviders = getMissingRequiredCliReviewAuthProviders(configuredApiKeys);
+    return {
+        apiKeys: configuredApiKeys,
+        missingModels: missingRequiredProviders.includes('OpenAI') ? ['openai'] : [],
+        missingProviders: missingRequiredProviders,
+    };
+}
+function getMissingAuthProviderFailures(missingModels) {
+    return missingModels.map((model) => ({
+        model,
+        message: `${PROVIDER_DISPLAY_NAMES[model]} authentication unavailable; run \`doistbot auth login\``,
+    }));
+}
+function formatMissingAuthForJson({ source, missingModels, }) {
+    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(missingModels),
+    };
+}
+async function runLocalReviewForCli({ source, apiKeys, models, onProgress, }) {
+    const reviewModule = await loadSandboxReviewModule();
+    return await reviewModule.runLocalReview({
+        workspaceDir: getRepositoryRoot(),
+        source,
+        apiKeys,
+        ...getCliReviewRouting(apiKeys, models),
+        suppressLogs: true,
+        onProgress,
+    });
+}
+export async function runReview({ source, json = false, models } = {
+    source: 'base',
+}) {
+    const authCheck = await getReviewAuthCheck(models);
+    if (authCheck.missingProviders.length > 0) {
+        if (json) {
+            writeLine(JSON.stringify(formatMissingAuthForJson({
+                source,
+                missingModels: authCheck.missingModels,
+            }), null, 2));
+            process.exitCode = 1;
+            return;
+        }
+        throw new Error(formatMissingRequiredCliAuthProviders(authCheck.missingProviders));
+    }
+    if (json) {
+        const result = await runLocalReviewForCli({ source, apiKeys: authCheck.apiKeys, models });
+        const output = formatReviewForJson(result);
+        writeLine(JSON.stringify(output, null, 2));
+        if (output.status === 'unverified') {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const result = await withSpinner(source === LOCAL_REVIEW_SOURCE_STAGED
+        ? 'Reviewing staged changes...'
+        : 'Reviewing local changes...', async (status) => await runLocalReviewForCli({
+        source,
+        apiKeys: authCheck.apiKeys,
+        models,
+        onProgress: status.enabled
+            ? (event) => status.update(formatReviewProgress(event))
+            : undefined,
+    }));
+    if (result.reviewResult.status === 'skipped') {
+        handleSkippedReview(result.reviewResult);
+        return;
+    }
+    const formatModule = await loadSandboxFormatModule();
+    if (result.reviewResult.providerFailures.length > 0 &&
+        getReviewFindingCount(result.reviewResult.review) === 0) {
+        throw new Error(formatProviderFailureMessage(result.reviewResult.providerFailures));
+    }
+    const output = formatReviewOutput({
+        formatReviewForTerminal: formatModule.formatReviewForTerminal,
+        review: result.reviewResult.review,
+    });
+    writeLine(renderMarkdown(output || 'No findings.'));
+    if (result.reviewResult.providerFailures.length > 0) {
+        writeLine();
+        writeLine();
+        writeLine(renderAlert(formatPartialProviderFailureMessage(result.reviewResult.providerFailures)));
+    }
+}

package/dist/actions/setup.js

@@ -0,0 +1,14 @@
+import { checkGit, checkPiDependency, checkSandboxBuild } from '../runtime.js';
+import { renderDiagnosticCheck, writeLine } from '../terminal.js';
+import { runAuthSetup } from './auth.js';
+import { formatSetupCompleteMessage } from './review-usage.js';
+export async function runSetup() {
+    writeLine('Checking Doistbot CLI prerequisites...');
+    await renderDiagnosticCheck('git', checkGit);
+    await renderDiagnosticCheck('pi', checkPiDependency);
+    await renderDiagnosticCheck('sandbox build', checkSandboxBuild);
+    writeLine();
+    await runAuthSetup();
+    writeLine();
+    writeLine(formatSetupCompleteMessage());
+}