@mcpilotx/intentorch 0.5.0

package/dist/core/config-manager.js

@@ -0,0 +1,400 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { CONFIG_PATH, MCPILOT_HOME, DEFAULT_CONFIG } from './constants.js';
+import { logger } from './logger.js';
+export class ConfigManager {
+    static CONFIG_DIR = MCPILOT_HOME;
+    static SERVICES_DIR = path.join(this.CONFIG_DIR, 'services');
+    static DOCKER_HOSTS_DIR = path.join(this.CONFIG_DIR, 'config', 'docker-hosts');
+    static RUNTIME_PROFILES_DIR = path.join(this.CONFIG_DIR, 'config', 'runtime-profiles');
+    static GLOBAL_CONFIG_PATH = CONFIG_PATH;
+    // Memory caches
+    static serviceConfigCache = new Map();
+    static servicesListCache = null;
+    static globalConfigCache = null;
+    static dockerHostsCache = new Map();
+    static runtimeProfilesCache = new Map();
+    static init() {
+        // Create configuration directory structure
+        const dirs = [
+            this.CONFIG_DIR,
+            path.join(this.CONFIG_DIR, 'config'),
+            this.SERVICES_DIR,
+            this.DOCKER_HOSTS_DIR,
+            this.RUNTIME_PROFILES_DIR,
+        ];
+        for (const dir of dirs) {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+        // Create default global configuration
+        if (!fs.existsSync(this.GLOBAL_CONFIG_PATH)) {
+            this.saveGlobalConfig(this.getDefaultGlobalConfig());
+        }
+        // Create default Docker host configuration
+        this.ensureDefaultDockerHosts();
+        // Create default runtime configuration templates
+        this.ensureDefaultRuntimeProfiles();
+        logger.info('Configuration system initialized');
+    }
+    // ==================== Service Configuration Management ====================
+    static getServiceConfig(serviceName) {
+        // Check cache first
+        if (this.serviceConfigCache.has(serviceName)) {
+            return this.serviceConfigCache.get(serviceName);
+        }
+        const configPath = this.getServiceConfigPath(serviceName);
+        if (!fs.existsSync(configPath)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            const config = JSON.parse(content);
+            // Cache the result
+            this.serviceConfigCache.set(serviceName, config);
+            return config;
+        }
+        catch (error) {
+            logger.error(`Failed to read service config for ${serviceName}: ${error.message}`);
+            return null;
+        }
+    }
+    static saveServiceConfig(serviceName, config) {
+        const configPath = this.getServiceConfigPath(serviceName);
+        const configDir = path.dirname(configPath);
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        try {
+            // Ensure path is absolute
+            if (!path.isAbsolute(config.path)) {
+                config.path = path.resolve(config.path);
+            }
+            // Add/update metadata
+            config.installedAt = config.installedAt || new Date().toISOString();
+            config.lastDetectedAt = new Date().toISOString();
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+            // Update cache
+            this.serviceConfigCache.set(serviceName, config);
+            this.servicesListCache = null; // Invalidate services list cache
+            logger.debug(`Service config saved: ${serviceName}`);
+        }
+        catch (error) {
+            logger.error(`Failed to save service config for ${serviceName}: ${error.message}`);
+            throw error;
+        }
+    }
+    static updateServiceDetection(serviceName, detection) {
+        const config = this.getServiceConfig(serviceName) || {
+            name: serviceName,
+            path: '', // Will be set by caller
+        };
+        config.detectedRuntime = detection.runtime;
+        config.detectionConfidence = detection.confidence;
+        config.detectionSource = detection.source;
+        config.detectionEvidence = detection.evidence;
+        config.detectionWarning = detection.warning;
+        config.lastDetectedAt = new Date().toISOString();
+        // If confidence is high, automatically update runtime
+        const globalConfig = this.getGlobalConfig();
+        if (detection.confidence >= globalConfig.detectionThreshold) {
+            config.runtime = detection.runtime;
+            logger.info(`Auto-updated runtime for ${serviceName}: ${detection.runtime} (confidence: ${detection.confidence})`);
+        }
+        this.saveServiceConfig(serviceName, config);
+        return config;
+    }
+    static setServiceRuntime(serviceName, runtime, runtimeConfig) {
+        const config = this.getServiceConfig(serviceName);
+        if (!config) {
+            throw new Error(`Service ${serviceName} not found`);
+        }
+        config.runtime = runtime;
+        config.detectionSource = 'explicit';
+        config.detectionConfidence = 1.0;
+        if (runtimeConfig) {
+            config.runtimeConfig = runtimeConfig;
+        }
+        this.saveServiceConfig(serviceName, config);
+        return config;
+    }
+    // ==================== Docker Host Configuration ====================
+    static getDockerHostConfig(hostName) {
+        const configPath = path.join(this.DOCKER_HOSTS_DIR, `${hostName}.json`);
+        if (!fs.existsSync(configPath)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            logger.error(`Failed to read Docker host config ${hostName}: ${error.message}`);
+            return null;
+        }
+    }
+    static saveDockerHostConfig(hostName, config) {
+        const configPath = path.join(this.DOCKER_HOSTS_DIR, `${hostName}.json`);
+        try {
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+            logger.debug(`Docker host config saved: ${hostName}`);
+        }
+        catch (error) {
+            logger.error(`Failed to save Docker host config ${hostName}: ${error.message}`);
+            throw error;
+        }
+    }
+    static deleteDockerHostConfig(hostName) {
+        const configPath = path.join(this.DOCKER_HOSTS_DIR, `${hostName}.json`);
+        try {
+            if (fs.existsSync(configPath)) {
+                fs.unlinkSync(configPath);
+                logger.debug(`Docker host config deleted: ${hostName}`);
+            }
+        }
+        catch (error) {
+            logger.error(`Failed to delete Docker host config ${hostName}: ${error.message}`);
+            throw error;
+        }
+    }
+    static listDockerHosts() {
+        if (!fs.existsSync(this.DOCKER_HOSTS_DIR)) {
+            return [];
+        }
+        return fs.readdirSync(this.DOCKER_HOSTS_DIR)
+            .filter(file => file.endsWith('.json'))
+            .map(file => path.basename(file, '.json'));
+    }
+    // ==================== Runtime Configuration Templates ====================
+    static getRuntimeProfile(runtime) {
+        const profilePath = path.join(this.RUNTIME_PROFILES_DIR, `${runtime}.json`);
+        if (!fs.existsSync(profilePath)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(profilePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            logger.error(`Failed to read runtime profile for ${runtime}: ${error.message}`);
+            return null;
+        }
+    }
+    static saveRuntimeProfile(runtime, config) {
+        const profilePath = path.join(this.RUNTIME_PROFILES_DIR, `${runtime}.json`);
+        try {
+            fs.writeFileSync(profilePath, JSON.stringify(config, null, 2));
+            logger.debug(`Runtime profile saved: ${runtime}`);
+        }
+        catch (error) {
+            logger.error(`Failed to save runtime profile for ${runtime}: ${error.message}`);
+            throw error;
+        }
+    }
+    // ==================== Global Configuration ====================
+    static getGlobalConfig() {
+        if (!fs.existsSync(this.GLOBAL_CONFIG_PATH)) {
+            return this.getDefaultGlobalConfig();
+        }
+        try {
+            const content = fs.readFileSync(this.GLOBAL_CONFIG_PATH, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            logger.error(`Failed to read global config: ${error.message}`);
+            return this.getDefaultGlobalConfig();
+        }
+    }
+    static saveGlobalConfig(config) {
+        try {
+            fs.writeFileSync(this.GLOBAL_CONFIG_PATH, JSON.stringify(config, null, 2));
+            logger.debug('Global config saved');
+        }
+        catch (error) {
+            logger.error(`Failed to save global config: ${error.message}`);
+            throw error;
+        }
+    }
+    // ==================== Helper Methods ====================
+    static getServiceConfigPath(serviceName) {
+        return path.join(this.SERVICES_DIR, serviceName, 'config.json');
+    }
+    static ensureDefaultDockerHosts() {
+        const defaultHosts = {
+            local: {
+                type: 'local',
+                socketPath: process.platform === 'win32'
+                    ? '//./pipe/docker_engine'
+                    : '/var/run/docker.sock',
+            },
+            'localhost-tcp': {
+                type: 'remote',
+                host: 'localhost',
+                port: 2375,
+            },
+            'localhost-tls': {
+                type: 'remote',
+                host: 'localhost',
+                port: 2376,
+                useTLS: true,
+            },
+        };
+        for (const [name, config] of Object.entries(defaultHosts)) {
+            const configPath = path.join(this.DOCKER_HOSTS_DIR, `${name}.json`);
+            if (!fs.existsSync(configPath)) {
+                this.saveDockerHostConfig(name, config);
+            }
+        }
+    }
+    static ensureDefaultRuntimeProfiles() {
+        const defaultProfiles = {
+            node: {
+                node: {
+                    npmRegistry: 'https://registry.npmmirror.com',
+                    bun: false,
+                    nodeVersion: '>=18.0.0',
+                },
+            },
+            python: {
+                python: {
+                    venv: true,
+                    mirror: 'https://pypi.tuna.tsinghua.edu.cn/simple',
+                    pythonVersion: '>=3.8',
+                },
+            },
+            docker: {
+                docker: {
+                    type: 'local',
+                    ports: [8080],
+                },
+            },
+            go: {
+                go: {
+                    build: true,
+                    goVersion: '>=1.20',
+                },
+            },
+            rust: {
+                rust: {
+                    release: true,
+                    rustVersion: '>=1.70',
+                },
+            },
+            binary: {
+            // Binary runtime has no special configuration
+            },
+        };
+        for (const [runtime, config] of Object.entries(defaultProfiles)) {
+            const profilePath = path.join(this.RUNTIME_PROFILES_DIR, `${runtime}.json`);
+            if (!fs.existsSync(profilePath)) {
+                this.saveRuntimeProfile(runtime, config);
+            }
+        }
+    }
+    static getDefaultGlobalConfig() {
+        return {
+            ...DEFAULT_CONFIG,
+            defaultDockerHost: 'local',
+            detectionThreshold: 0.7,
+            requireExplicitRuntime: false,
+            autoSaveDetection: true,
+            interactiveMode: true,
+            logLevel: 'info',
+        };
+    }
+    // ==================== Configuration Parsing and Merging ====================
+    static resolveServiceConfig(userConfig, servicePath) {
+        const baseConfig = {
+            name: userConfig.name || path.basename(servicePath),
+            path: servicePath,
+        };
+        // Merge user configuration
+        const mergedConfig = { ...baseConfig, ...userConfig };
+        // Ensure path is absolute
+        if (!path.isAbsolute(mergedConfig.path)) {
+            mergedConfig.path = path.resolve(mergedConfig.path);
+        }
+        // If user specified runtime, set highest priority
+        if (mergedConfig.runtime) {
+            mergedConfig.detectionSource = 'explicit';
+            mergedConfig.detectionConfidence = 1.0;
+        }
+        // Apply runtime configuration template
+        if (mergedConfig.runtime && !mergedConfig.runtimeConfig) {
+            const profile = this.getRuntimeProfile(mergedConfig.runtime);
+            if (profile) {
+                mergedConfig.runtimeConfig = profile;
+            }
+        }
+        return mergedConfig;
+    }
+    // ==================== Configuration validation ====================
+    static validateServiceConfig(config) {
+        const errors = [];
+        if (!config.name) {
+            errors.push('Service name is required');
+        }
+        if (!config.path) {
+            errors.push('Service path is required');
+        }
+        else if (!fs.existsSync(config.path)) {
+            errors.push(`Service path does not exist: ${config.path}`);
+        }
+        if (!config.runtime && !config.detectedRuntime) {
+            errors.push('Runtime type is required (either explicit or detected)');
+        }
+        if (config.detectionConfidence !== undefined) {
+            if (config.detectionConfidence < 0 || config.detectionConfidence > 1) {
+                errors.push(`Detection confidence must be between 0 and 1, got ${config.detectionConfidence}`);
+            }
+        }
+        return errors;
+    }
+    // ==================== Configuration Utility Methods ====================
+    static getAllServices() {
+        // Check cache first
+        if (this.servicesListCache !== null) {
+            return this.servicesListCache;
+        }
+        if (!fs.existsSync(this.SERVICES_DIR)) {
+            this.servicesListCache = [];
+            return [];
+        }
+        const services = fs.readdirSync(this.SERVICES_DIR, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => dirent.name);
+        // Cache the result
+        this.servicesListCache = services;
+        return services;
+    }
+    static getServiceDetectionCache(serviceName) {
+        const cachePath = path.join(this.SERVICES_DIR, serviceName, 'detection-cache.json');
+        if (!fs.existsSync(cachePath)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(cachePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            logger.error(`Failed to read detection cache for ${serviceName}: ${error.message}`);
+            return null;
+        }
+    }
+    static saveServiceDetectionCache(serviceName, detection) {
+        const cachePath = path.join(this.SERVICES_DIR, serviceName, 'detection-cache.json');
+        const cacheDir = path.dirname(cachePath);
+        if (!fs.existsSync(cacheDir)) {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        try {
+            fs.writeFileSync(cachePath, JSON.stringify(detection, null, 2));
+            logger.debug(`Detection cache saved for ${serviceName}`);
+        }
+        catch (error) {
+            logger.error(`Failed to save detection cache for ${serviceName}: ${error.message}`);
+        }
+    }
+}
+//# sourceMappingURL=config-manager.js.map

package/dist/core/config-validator.d.ts

@@ -0,0 +1,9 @@
+import { Config } from './types';
+export declare class ConfigValidator {
+    static validate(config: any): Config;
+    private static checkRequiredConfig;
+    static getDefaultConfig(): Config;
+    static mergeWithDefaults(userConfig: any): Config;
+    static validateAIConfig(aiConfig: any): any;
+}
+//# sourceMappingURL=config-validator.d.ts.map

package/dist/core/config-validator.js

@@ -0,0 +1,184 @@
+import { DEFAULT_CONFIG } from './constants.js';
+import { logger } from './logger.js';
+export class ConfigValidator {
+    static validate(config) {
+        const validated = {
+            ai: {
+                provider: 'deepseek',
+                model: 'deepseek-v3',
+                apiKey: '',
+            },
+            registry: {
+                preferred: 'gitee-mcp',
+            },
+            services: {
+                autoStart: [],
+            },
+        };
+        // Handle null or undefined config
+        if (!config) {
+            return validated;
+        }
+        // Validate AI configuration
+        if (config.ai) {
+            // Validate provider
+            if (typeof config.ai.provider === 'string') {
+                const validProviders = ['openai', 'anthropic', 'deepseek', 'cohere', 'ollama', 'local', 'custom'];
+                if (validProviders.includes(config.ai.provider)) {
+                    validated.ai.provider = config.ai.provider;
+                }
+                else {
+                    logger.warn(`Invalid AI provider "${config.ai.provider}" in config, using default "deepseek"`);
+                }
+            }
+            else {
+                logger.warn('Invalid AI provider in config, using default');
+            }
+            // Validate model
+            if (typeof config.ai.model === 'string') {
+                validated.ai.model = config.ai.model;
+            }
+            else {
+                logger.warn('Invalid AI model in config, using default');
+            }
+            // Validate apiKey
+            if (typeof config.ai.apiKey === 'string') {
+                validated.ai.apiKey = config.ai.apiKey;
+            }
+            // Validate apiEndpoint
+            if (typeof config.ai.apiEndpoint === 'string') {
+                validated.ai.apiEndpoint = config.ai.apiEndpoint;
+            }
+            // Validate timeout
+            if (typeof config.ai.timeout === 'number' && config.ai.timeout > 0) {
+                validated.ai.timeout = config.ai.timeout;
+            }
+            // Validate maxTokens
+            if (typeof config.ai.maxTokens === 'number' && config.ai.maxTokens > 0) {
+                validated.ai.maxTokens = config.ai.maxTokens;
+            }
+            // Validate temperature
+            if (typeof config.ai.temperature === 'number' && config.ai.temperature >= 0 && config.ai.temperature <= 2) {
+                validated.ai.temperature = config.ai.temperature;
+            }
+            // Validate embeddingProvider
+            if (typeof config.ai.embeddingProvider === 'string') {
+                validated.ai.embeddingProvider = config.ai.embeddingProvider;
+            }
+            // Validate embeddingApiKey
+            if (typeof config.ai.embeddingApiKey === 'string') {
+                validated.ai.embeddingApiKey = config.ai.embeddingApiKey;
+            }
+            // Validate embeddingModel
+            if (typeof config.ai.embeddingModel === 'string') {
+                validated.ai.embeddingModel = config.ai.embeddingModel;
+            }
+            // Validate embeddingEndpoint
+            if (typeof config.ai.embeddingEndpoint === 'string') {
+                validated.ai.embeddingEndpoint = config.ai.embeddingEndpoint;
+            }
+            // Validate localModelPath
+            if (typeof config.ai.localModelPath === 'string') {
+                validated.ai.localModelPath = config.ai.localModelPath;
+            }
+            // Validate ollamaHost
+            if (typeof config.ai.ollamaHost === 'string') {
+                validated.ai.ollamaHost = config.ai.ollamaHost;
+            }
+            // Validate customConfig
+            if (config.ai.customConfig && typeof config.ai.customConfig === 'object') {
+                validated.ai.customConfig = config.ai.customConfig;
+            }
+        }
+        // Validate registry configuration
+        if (config.registry) {
+            if (typeof config.registry.preferred === 'string') {
+                validated.registry.preferred = config.registry.preferred;
+            }
+            else {
+                logger.warn('Invalid registry preference in config, using default');
+            }
+            // Validate customRegistries
+            if (config.registry.customRegistries && typeof config.registry.customRegistries === 'object') {
+                validated.registry.customRegistries = config.registry.customRegistries;
+            }
+        }
+        // Validate service configuration
+        if (config.services) {
+            if (Array.isArray(config.services.autoStart)) {
+                validated.services.autoStart = config.services.autoStart.filter((service) => typeof service === 'string');
+            }
+            else {
+                logger.warn('Invalid autoStart configuration, using empty array');
+            }
+            // Validate defaultTimeout
+            if (typeof config.services.defaultTimeout === 'number' && config.services.defaultTimeout > 0) {
+                validated.services.defaultTimeout = config.services.defaultTimeout;
+            }
+        }
+        // Check required configuration
+        this.checkRequiredConfig(validated);
+        return validated;
+    }
+    static checkRequiredConfig(config) {
+        // Check AI configuration
+        const aiConfig = config.ai;
+        // Check AI API key (if using providers that require API key)
+        const providersRequiringKey = ['openai', 'anthropic', 'deepseek', 'cohere'];
+        if (providersRequiringKey.includes(aiConfig.provider) && !aiConfig.apiKey) {
+            logger.warn(`AI provider ${aiConfig.provider} requires an API key but none was provided`);
+        }
+        // Check local model configuration
+        if (aiConfig.provider === 'local' && !aiConfig.localModelPath) {
+            logger.warn('Local AI provider selected but no localModelPath specified');
+        }
+        // Check Ollama configuration
+        if (aiConfig.provider === 'ollama') {
+            if (!aiConfig.ollamaHost) {
+                logger.info('Ollama provider selected, using default host: http://localhost:11434');
+                aiConfig.ollamaHost = 'http://localhost:11434';
+            }
+            if (!aiConfig.model) {
+                logger.warn('Ollama provider selected but no model specified');
+            }
+        }
+        // Check custom provider configuration
+        if (aiConfig.provider === 'custom' && !aiConfig.apiEndpoint) {
+            logger.warn('Custom AI provider selected but no apiEndpoint specified');
+        }
+        // Check if auto-start services are valid
+        if (config.services.autoStart.length > 0) {
+            logger.info(`Services configured for auto-start: ${config.services.autoStart.join(', ')}`);
+        }
+        // Check registry configuration
+        if (config.registry.customRegistries) {
+            const customRegistryCount = Object.keys(config.registry.customRegistries).length;
+            if (customRegistryCount > 0) {
+                logger.info(`Loaded ${customRegistryCount} custom registry configuration(s)`);
+            }
+        }
+    }
+    static getDefaultConfig() {
+        return DEFAULT_CONFIG;
+    }
+    static mergeWithDefaults(userConfig) {
+        const defaultConfig = this.getDefaultConfig();
+        const merged = {
+            ai: { ...defaultConfig.ai, ...(userConfig.ai || {}) },
+            registry: { ...defaultConfig.registry, ...(userConfig.registry || {}) },
+            services: { ...defaultConfig.services, ...(userConfig.services || {}) },
+        };
+        return this.validate(merged);
+    }
+    static validateAIConfig(aiConfig) {
+        // Create a mock config with just the AI config for validation
+        const mockConfig = {
+            ai: aiConfig,
+            registry: { preferred: 'gitee-mcp' },
+            services: { autoStart: [] },
+        };
+        const validated = this.validate(mockConfig);
+        return validated.ai;
+    }
+}
+//# sourceMappingURL=config-validator.js.map

package/dist/core/constants.d.ts

@@ -0,0 +1,34 @@
+export declare const MCPILOT_HOME: string;
+export declare const MCPILOT_DIR: string;
+export declare const SOCKET_PATH: string;
+export declare const LOGS_DIR: string;
+export declare const SERVERS_DIR: string;
+export declare const VENVS_DIR: string;
+export declare const CONFIG_PATH: string;
+export declare const DEFAULT_CONFIG: {
+    ai: {
+        enabled: boolean;
+        provider: string;
+        model: string;
+        apiKey: string;
+        timeout: number;
+        maxTokens: number;
+        temperature: number;
+        embeddingProvider: string;
+        embeddingApiKey: string;
+        embeddingModel: string;
+        embeddingEndpoint: string;
+        useLocalEmbeddings: boolean;
+        useVectorSearch: boolean;
+        transformersTimeout: number;
+        fallbackMode: string;
+    };
+    registry: {
+        preferred: string;
+    };
+    services: {
+        autoStart: string[];
+        defaultTimeout: number;
+    };
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/core/constants.js

@@ -0,0 +1,37 @@
+import * as os from 'os';
+import * as path from 'path';
+export const MCPILOT_HOME = path.join(os.homedir(), '.mcpilot');
+export const MCPILOT_DIR = MCPILOT_HOME; // Alias for backward compatibility
+export const SOCKET_PATH = path.join(MCPILOT_HOME, 'run', 'mcp.sock');
+export const LOGS_DIR = path.join(MCPILOT_HOME, 'logs');
+export const SERVERS_DIR = path.join(MCPILOT_HOME, 'servers');
+export const VENVS_DIR = path.join(MCPILOT_HOME, 'venvs');
+export const CONFIG_PATH = path.join(MCPILOT_HOME, 'config.json');
+export const DEFAULT_CONFIG = {
+    ai: {
+        enabled: true, // Whether to enable AI functionality
+        provider: 'deepseek',
+        model: 'deepseek-v3',
+        apiKey: '',
+        timeout: 30000, // 30 second timeout
+        maxTokens: 2048,
+        temperature: 0.7,
+        // Embedding-specific configuration
+        embeddingProvider: '',
+        embeddingApiKey: '',
+        embeddingModel: '',
+        embeddingEndpoint: '',
+        useLocalEmbeddings: false, // Whether to use local transformers for text embedding
+        useVectorSearch: true, // Whether to use vector search
+        transformersTimeout: 5000, // Transformers loading timeout (milliseconds)
+        fallbackMode: 'lightweight', // Fallback mode: 'lightweight' | 'simple' | 'disabled'
+    },
+    registry: {
+        preferred: 'gitee-mcp',
+    },
+    services: {
+        autoStart: ['filesystem'],
+        defaultTimeout: 60000, // 60 second default timeout
+    },
+};
+//# sourceMappingURL=constants.js.map

package/dist/core/error-ai.d.ts

@@ -0,0 +1,23 @@
+import { AIProvider } from './types';
+export interface AIError {
+    type: 'config' | 'connection' | 'validation' | 'authentication' | 'unknown';
+    message: string;
+    provider?: AIProvider;
+    details?: any;
+}
+export declare class AIErrorHandler {
+    static handleError(error: AIError): void;
+    private static getSuggestions;
+    private static printNextSteps;
+    private static getProviderWebsite;
+    static handleProviderError(input: string, similarProviders?: Array<{
+        provider: AIProvider;
+        similarity: number;
+        distance: number;
+    }>): void;
+    static handleModelError(provider: AIProvider, model: string, availableModels?: string[]): void;
+    static handleApiKeyError(provider: AIProvider): void;
+    private static getEnvVarName;
+    static handleTestResult(success: boolean, provider?: AIProvider, details?: any): void;
+}
+//# sourceMappingURL=error-ai.d.ts.map