vibe-coder-mcp/build/cli/utils/config-loader.js

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

import { validateCLIConfig } from '../types/index.js';
import { OpenRouterConfigManager } from '../../utils/openrouter-config-manager.js';
import { getUnifiedSecurityConfig } from '../../tools/vibe-task-manager/security/unified-security-config.js';
import logger from '../../logger.js';
export async function loadOpenRouterConfig() {
    try {
        const configManager = OpenRouterConfigManager.getInstance();
        await configManager.initialize();
        const config = await configManager.getOpenRouterConfig();
        logger.debug('CLI loaded OpenRouter configuration via centralized manager');
        return config;
    }
    catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown configuration error';
        logger.error({ err: error }, 'CLI failed to load centralized OpenRouter configuration');
        throw new Error(`Failed to load OpenRouter configuration: ${message}`);
    }
}
export async function getCLISecurityBoundaries() {
    try {
        const securityManager = await getUnifiedSecurityConfig();
        const securityConfig = securityManager.getConfig();
        return {
            allowedReadDirectories: [securityConfig.allowedReadDirectory],
            allowedWriteDirectory: securityConfig.allowedWriteDirectory,
            securityMode: securityConfig.securityMode
        };
    }
    catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown security error';
        logger.error({ err: error }, 'CLI failed to load unified security configuration');
        throw new Error(`Failed to load security configuration: ${message}`);
    }
}
export function parseCliArgs(args) {
    const argSet = new Set(args);
    const rawConfig = {
        verbose: argSet.has('--verbose') || argSet.has('-v'),
        quiet: argSet.has('--quiet') || argSet.has('-q'),
        color: !argSet.has('--no-color'),
        outputFormat: getOutputFormat(args)
    };
    return validateCLIConfig(rawConfig);
}
function getOutputFormat(args) {
    const formatIndex = args.indexOf('--format');
    if (formatIndex !== -1 && formatIndex + 1 < args.length) {
        const format = args[formatIndex + 1];
        if (format === 'json' || format === 'yaml' || format === 'text') {
            return format;
        }
    }
    if (args.includes('--json'))
        return 'json';
    if (args.includes('--yaml'))
        return 'yaml';
    return 'text';
}
export function extractRequestArgs(args) {
    const flagsToSkip = new Set([
        '--verbose', '-v',
        '--quiet', '-q',
        '--no-color',
        '--json',
        '--yaml',
        '--help', '-h'
    ]);
    const result = [];
    let skipNext = false;
    for (let i = 0; i < args.length; i++) {
        const arg = args[i];
        if (skipNext) {
            skipNext = false;
            continue;
        }
        if (arg === '--format') {
            skipNext = true;
            continue;
        }
        if (!arg.startsWith('-') || !flagsToSkip.has(arg)) {
            if (!arg.startsWith('-')) {
                result.push(arg);
            }
        }
    }
    return result;
}
export function shouldDisplayHelp(args) {
    return args.length === 0 ||
        args.includes('--help') ||
        args.includes('-h');
}
export function generateSessionId() {
    return `cli-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
}
export async function validateEnvironment() {
    const errors = [];
    try {
        const nodeVersion = process.version;
        const majorVersion = parseInt(nodeVersion.slice(1).split('.')[0]);
        if (majorVersion < 20) {
            errors.push(`Node.js 20.0.0+ is required. Current version: ${nodeVersion}`);
        }
        const configManager = OpenRouterConfigManager.getInstance();
        const configValidation = configManager.validateConfiguration();
        if (!configValidation.valid) {
            errors.push(...configValidation.errors.map(e => `Configuration: ${e}`));
        }
        try {
            await loadOpenRouterConfig();
        }
        catch (error) {
            const message = error instanceof Error ? error.message : 'Unknown OpenRouter error';
            errors.push(`OpenRouter configuration: ${message}`);
        }
    }
    catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown validation error';
        errors.push(`Environment validation: ${message}`);
    }
    return {
        valid: errors.length === 0,
        errors
    };
}
export async function initializeCLIConfiguration() {
    try {
        logger.info('Initializing CLI configuration via centralized systems');
        const configManager = OpenRouterConfigManager.getInstance();
        await configManager.initialize();
        const openRouterConfig = await configManager.getOpenRouterConfig();
        const securityBoundaries = await getCLISecurityBoundaries();
        logger.info('CLI configuration initialized successfully via centralized systems');
        return {
            openRouterConfig,
            securityBoundaries
        };
    }
    catch (error) {
        const message = error instanceof Error ? error.message : 'Unknown initialization error';
        logger.error({ err: error }, 'Failed to initialize CLI configuration via centralized systems');
        throw new Error(`CLI configuration initialization failed: ${message}`);
    }
}