review-copilot/dist/providers/provider-factory.js

ReviewCopilot - AI-powered code review assistant with customizable prompts

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProviderFactory = void 0;
const openai_provider_1 = require("./openai-provider");
const deepseek_provider_1 = require("./deepseek-provider");
const chalk_1 = __importDefault(require("chalk"));
class ProviderFactory {
    static createProvider(config) {
        if (!config.providers) {
            throw new Error('No providers configuration found. Please update your configuration to use the new format.');
        }
        const enabledProviders = Object.entries(config.providers).filter(([_, providerConfig]) => providerConfig?.enabled);
        if (enabledProviders.length === 0) {
            throw new Error('No AI provider is enabled in the configuration. Please enable one provider in the providers section.');
        }
        if (enabledProviders.length > 1) {
            throw new Error('Multiple AI providers are enabled. Please enable only one provider.');
        }
        const [providerName, providerConfig] = enabledProviders[0];
        if (!providerConfig) {
            throw new Error(`Provider configuration for ${providerName} is undefined`);
        }
        // Ensure all required fields are present
        const requiredFields = [
            'apiKey',
            'model',
            'baseURL',
        ];
        const missingFields = requiredFields.filter((field) => !providerConfig[field]);
        if (missingFields.length > 0) {
            throw new Error(`Missing required fields for ${providerName} provider: ${missingFields.join(', ')}`);
        }
        console.log(chalk_1.default.blue(`Using ${providerName} as AI provider`));
        const { enabled, ...providerSettings } = providerConfig;
        const settings = {
            ...providerSettings,
            provider: providerName.toLowerCase(),
        };
        this.validateProviderConfig(providerName, settings);
        switch (providerName.toLowerCase()) {
            case 'openai':
                return new openai_provider_1.OpenAIProvider(settings);
            case 'deepseek':
                return new deepseek_provider_1.DeepSeekProvider(settings);
            default:
                throw new Error(`Unsupported AI provider: ${providerName}`);
        }
    }
    static validateConfig(config) {
        if (!config.providers) {
            throw new Error('No providers configuration found');
        }
        Object.entries(config.providers).forEach(([name, providerConfig]) => {
            if (providerConfig?.enabled) {
                const settings = {
                    ...providerConfig,
                    provider: name.toLowerCase(),
                };
                this.validateProviderConfig(name, settings);
            }
        });
    }
    static validateProviderConfig(name, config) {
        const requiredFields = [
            'apiKey',
            'model',
            'baseURL',
            'provider',
        ];
        const missingFields = requiredFields.filter((field) => !config[field]);
        if (missingFields.length > 0) {
            throw new Error(`Missing required fields for ${name} provider: ${missingFields.join(', ')}`);
        }
        // Validate baseURL format
        if (!config.baseURL.endsWith('/v1')) {
            console.warn(chalk_1.default.yellow(`Warning: ${name} provider baseURL should typically end with '/v1'`));
        }
    }
}
exports.ProviderFactory = ProviderFactory;