vibe-coder-mcp/build/utils/configLoader.js

Production-ready MCP server with complete agent integration, multi-transport support, and comprehensive development automation tools for AI-assisted workflows.

import fs from 'fs-extra';
import path from 'path';
import logger from '../logger.js';
export function loadLlmConfigMapping(fileName = 'llm_config.json') {
    let filePath = null;
    const defaultMapping = {};
    if (process.env.LLM_CONFIG_PATH) {
        const envPath = process.env.LLM_CONFIG_PATH;
        if (fs.existsSync(envPath)) {
            logger.info(`Found LLM config path in environment variable: ${envPath}`);
            filePath = envPath;
        }
        else {
            logger.warn(`LLM_CONFIG_PATH environment variable set to ${envPath}, but file not found.`);
        }
    }
    if (!filePath) {
        const cwdPath = path.join(process.cwd(), fileName);
        if (fs.existsSync(cwdPath)) {
            logger.info(`Found LLM config in current working directory: ${cwdPath}`);
            filePath = cwdPath;
        }
    }
    if (filePath) {
        try {
            const fileContent = fs.readFileSync(filePath, 'utf-8');
            const parsedConfig = JSON.parse(fileContent);
            if (parsedConfig && typeof parsedConfig.llm_mapping === 'object' && parsedConfig.llm_mapping !== null) {
                logger.info(`LLM config loaded successfully from ${filePath}`);
                for (const key in parsedConfig.llm_mapping) {
                    if (typeof parsedConfig.llm_mapping[key] !== 'string') {
                        logger.warn(`Invalid non-string value found for key "${key}" in ${filePath}. Skipping this key.`);
                        delete parsedConfig.llm_mapping[key];
                    }
                }
                return parsedConfig.llm_mapping;
            }
            else {
                logger.error(`Invalid structure in ${filePath}. Expected 'llm_mapping' object. Using default empty mapping.`);
                return defaultMapping;
            }
        }
        catch (error) {
            logger.error({ err: error, filePath }, `Failed to load or parse LLM config from ${filePath}. Using default empty mapping.`);
            return defaultMapping;
        }
    }
    else {
        logger.error(`LLM config file "${fileName}" not found via environment variable or in CWD (${process.cwd()}). Using default empty LLM mapping.`);
        return defaultMapping;
    }
}
export function selectModelForTask(config, logicalTaskName, defaultModel) {
    logger.debug({
        receivedConfig: config,
        receivedMapping: config?.llm_mapping,
        taskName: logicalTaskName
    }, 'selectModelForTask received config');
    const mapping = config?.llm_mapping;
    if (!mapping || typeof mapping !== 'object') {
        logger.warn({ logicalTaskName, configProvided: !!config }, `LLM mapping object is missing or invalid in provided config. Falling back to default model: ${defaultModel}`);
        return defaultModel;
    }
    const mappingKeys = Object.keys(mapping);
    if (mappingKeys.length === 0) {
        logger.warn({ logicalTaskName }, `LLM mapping object is empty. Falling back to default model: ${defaultModel}`);
        return defaultModel;
    }
    const modelFromMapping = mapping[logicalTaskName];
    const defaultFromMapping = mapping['default_generation'];
    logger.debug({
        logicalTaskName,
        mappingKeys: mappingKeys,
        modelFromMapping: modelFromMapping,
        defaultFromMapping: defaultFromMapping,
        defaultModelProvided: defaultModel
    }, `Looking up model for task: ${logicalTaskName}`);
    const modelToUse = modelFromMapping || defaultFromMapping || defaultModel;
    logger.info({ logicalTaskName, modelFromMapping, defaultFromMapping, defaultModel, modelToUse }, 'Model selection decision for task');
    return modelToUse;
}