@mcpilotx/intentorch 0.5.0

package/dist/core/performance-monitor.d.ts

@@ -0,0 +1,74 @@
+export interface PerformanceMetrics {
+    timestamp: number;
+    cpuUsage: {
+        user: number;
+        system: number;
+        total: number;
+    };
+    memoryUsage: {
+        rss: number;
+        heapTotal: number;
+        heapUsed: number;
+        external: number;
+    };
+    systemMetrics: {
+        totalMemory: number;
+        freeMemory: number;
+        loadAverage: number[];
+        uptime: number;
+    };
+    serviceMetrics: {
+        [serviceName: string]: {
+            cpu: number;
+            memory: number;
+            uptime: number;
+            requestCount: number;
+            errorCount: number;
+            responseTime: number;
+            errorRate?: number;
+        };
+    };
+}
+export interface PerformanceConfig {
+    enabled: boolean;
+    collectionInterval: number;
+    retentionPeriod: number;
+    alertThresholds: {
+        cpu: number;
+        memory: number;
+        responseTime: number;
+        errorRate: number;
+    };
+}
+export declare class PerformanceMonitor {
+    private metrics;
+    private config;
+    private collectionTimer;
+    private serviceStats;
+    constructor(config?: Partial<PerformanceConfig>);
+    start(): void;
+    stop(): void;
+    private collectMetrics;
+    private getCpuUsage;
+    private getMemoryUsage;
+    private getSystemMetrics;
+    private getServiceMetrics;
+    private cleanupOldMetrics;
+    private checkAlerts;
+    updateServiceStats(serviceName: string, stats: any): void;
+    recordServiceRequest(serviceName: string, duration: number, success?: boolean): void;
+    getMetrics(timeRange?: {
+        start: number;
+        end: number;
+    }): PerformanceMetrics[];
+    getSummary(): any;
+    private checkForAlertsInternal;
+    reset(): void;
+    getConfig(): PerformanceConfig;
+    updateConfig(newConfig: Partial<PerformanceConfig>): void;
+}
+export declare function getPerformanceMonitor(config?: Partial<PerformanceConfig>): PerformanceMonitor;
+export declare function startPerformanceMonitoring(config?: Partial<PerformanceConfig>): PerformanceMonitor;
+export declare function stopPerformanceMonitoring(): void;
+export declare function recordServicePerformance(serviceName: string, operation: string, duration: number, success?: boolean): void;
+//# sourceMappingURL=performance-monitor.d.ts.map

package/dist/core/performance-monitor.js

@@ -0,0 +1,260 @@
+import * as os from 'os';
+import { logger } from './logger.js';
+export class PerformanceMonitor {
+    metrics = [];
+    config;
+    collectionTimer = null;
+    serviceStats = new Map();
+    constructor(config) {
+        this.config = {
+            enabled: true,
+            collectionInterval: 60000, // 1 minute
+            retentionPeriod: 3600000, // 1 hour
+            alertThresholds: {
+                cpu: 80,
+                memory: 80,
+                responseTime: 1000,
+                errorRate: 5,
+            },
+            ...config,
+        };
+        if (this.config.enabled) {
+            this.start();
+        }
+    }
+    start() {
+        if (this.collectionTimer) {
+            this.stop();
+        }
+        logger.info('Performance monitoring started');
+        this.collectionTimer = setInterval(() => {
+            this.collectMetrics();
+            this.cleanupOldMetrics();
+            this.checkAlerts();
+        }, this.config.collectionInterval);
+        // Collect metrics immediately
+        this.collectMetrics();
+    }
+    stop() {
+        if (this.collectionTimer) {
+            clearInterval(this.collectionTimer);
+            this.collectionTimer = null;
+            logger.info('Performance monitoring stopped');
+        }
+    }
+    collectMetrics() {
+        try {
+            const metrics = {
+                timestamp: Date.now(),
+                cpuUsage: this.getCpuUsage(),
+                memoryUsage: this.getMemoryUsage(),
+                systemMetrics: this.getSystemMetrics(),
+                serviceMetrics: this.getServiceMetrics(),
+            };
+            this.metrics.push(metrics);
+            logger.debug('Performance metrics collected', { timestamp: metrics.timestamp });
+        }
+        catch (error) {
+            logger.error('Failed to collect performance metrics', { error: error.message });
+        }
+    }
+    getCpuUsage() {
+        const usage = process.cpuUsage();
+        return {
+            user: usage.user / 1000, // microseconds to milliseconds
+            system: usage.system / 1000,
+            total: (usage.user + usage.system) / 1000,
+        };
+    }
+    getMemoryUsage() {
+        const memory = process.memoryUsage();
+        return {
+            rss: memory.rss,
+            heapTotal: memory.heapTotal,
+            heapUsed: memory.heapUsed,
+            external: memory.external,
+        };
+    }
+    getSystemMetrics() {
+        return {
+            totalMemory: os.totalmem(),
+            freeMemory: os.freemem(),
+            loadAverage: os.loadavg(),
+            uptime: os.uptime(),
+        };
+    }
+    getServiceMetrics() {
+        const serviceMetrics = {};
+        for (const [serviceName, stats] of this.serviceStats) {
+            serviceMetrics[serviceName] = {
+                cpu: stats.cpu || 0,
+                memory: stats.memory || 0,
+                uptime: stats.uptime || 0,
+                requestCount: stats.requestCount || 0,
+                errorCount: stats.errorCount || 0,
+                responseTime: stats.responseTime || 0,
+                errorRate: stats.errorRate || 0,
+            };
+        }
+        return serviceMetrics;
+    }
+    cleanupOldMetrics() {
+        const cutoff = Date.now() - this.config.retentionPeriod;
+        this.metrics = this.metrics.filter(m => m.timestamp >= cutoff);
+    }
+    checkAlerts() {
+        if (this.metrics.length === 0) {
+            return;
+        }
+        const latest = this.metrics[this.metrics.length - 1];
+        // Check CPU usage
+        const cpuPercent = (latest.cpuUsage.total / 1000) * 100; // rough estimate
+        if (cpuPercent > this.config.alertThresholds.cpu) {
+            logger.warn(`High CPU usage detected: ${cpuPercent.toFixed(1)}%`, {
+                threshold: this.config.alertThresholds.cpu,
+                metrics: latest.cpuUsage,
+            });
+        }
+        // Check memory usage
+        const memoryPercent = (latest.memoryUsage.heapUsed / latest.memoryUsage.heapTotal) * 100;
+        if (memoryPercent > this.config.alertThresholds.memory) {
+            logger.warn(`High memory usage detected: ${memoryPercent.toFixed(1)}%`, {
+                threshold: this.config.alertThresholds.memory,
+                metrics: latest.memoryUsage,
+            });
+        }
+        // Check service metrics
+        for (const [serviceName, metrics] of Object.entries(latest.serviceMetrics)) {
+            if (metrics.errorRate > this.config.alertThresholds.errorRate) {
+                logger.warn(`High error rate for service ${serviceName}: ${metrics.errorRate.toFixed(1)}%`, {
+                    threshold: this.config.alertThresholds.errorRate,
+                    metrics,
+                });
+            }
+            if (metrics.responseTime > this.config.alertThresholds.responseTime) {
+                logger.warn(`High response time for service ${serviceName}: ${metrics.responseTime}ms`, {
+                    threshold: this.config.alertThresholds.responseTime,
+                    metrics,
+                });
+            }
+        }
+    }
+    updateServiceStats(serviceName, stats) {
+        this.serviceStats.set(serviceName, {
+            ...this.serviceStats.get(serviceName),
+            ...stats,
+            lastUpdated: Date.now(),
+        });
+    }
+    recordServiceRequest(serviceName, duration, success = true) {
+        const stats = this.serviceStats.get(serviceName) || {
+            requestCount: 0,
+            errorCount: 0,
+            totalResponseTime: 0,
+            startTime: Date.now(),
+        };
+        stats.requestCount++;
+        if (!success) {
+            stats.errorCount++;
+        }
+        stats.totalResponseTime += duration;
+        stats.responseTime = stats.totalResponseTime / stats.requestCount;
+        stats.errorRate = (stats.errorCount / stats.requestCount) * 100;
+        stats.uptime = Date.now() - stats.startTime;
+        this.updateServiceStats(serviceName, stats);
+    }
+    getMetrics(timeRange) {
+        if (!timeRange) {
+            return [...this.metrics];
+        }
+        return this.metrics.filter(m => m.timestamp >= timeRange.start && m.timestamp <= timeRange.end);
+    }
+    getSummary() {
+        if (this.metrics.length === 0) {
+            return { message: 'No metrics available' };
+        }
+        const latest = this.metrics[this.metrics.length - 1];
+        const oldest = this.metrics[0];
+        const duration = latest.timestamp - oldest.timestamp;
+        // Calculate averages
+        const avgCpu = this.metrics.reduce((sum, m) => sum + m.cpuUsage.total, 0) / this.metrics.length;
+        const avgMemory = this.metrics.reduce((sum, m) => sum + m.memoryUsage.heapUsed, 0) / this.metrics.length;
+        const avgMemoryPercent = (avgMemory / latest.memoryUsage.heapTotal) * 100;
+        return {
+            timeRange: {
+                start: oldest.timestamp,
+                end: latest.timestamp,
+                duration,
+            },
+            averages: {
+                cpuUsage: avgCpu,
+                memoryUsage: avgMemory,
+                memoryPercent: avgMemoryPercent,
+            },
+            current: {
+                cpuUsage: latest.cpuUsage,
+                memoryUsage: latest.memoryUsage,
+                systemMetrics: latest.systemMetrics,
+            },
+            services: Object.keys(latest.serviceMetrics).length,
+            alerts: this.checkForAlertsInternal(),
+        };
+    }
+    checkForAlertsInternal() {
+        const alerts = [];
+        const latest = this.metrics[this.metrics.length - 1];
+        if (!latest) {
+            return alerts;
+        }
+        // More complex alert logic can be added here
+        return alerts;
+    }
+    reset() {
+        this.metrics = [];
+        this.serviceStats.clear();
+        logger.info('Performance metrics reset');
+    }
+    getConfig() {
+        return { ...this.config };
+    }
+    updateConfig(newConfig) {
+        this.config = { ...this.config, ...newConfig };
+        if (this.config.enabled && !this.collectionTimer) {
+            this.start();
+        }
+        else if (!this.config.enabled && this.collectionTimer) {
+            this.stop();
+        }
+        logger.info('Performance monitor configuration updated', { config: this.config });
+    }
+}
+// Singleton instance
+let performanceMonitor = null;
+export function getPerformanceMonitor(config) {
+    if (!performanceMonitor) {
+        performanceMonitor = new PerformanceMonitor(config);
+    }
+    return performanceMonitor;
+}
+export function startPerformanceMonitoring(config) {
+    const monitor = getPerformanceMonitor(config);
+    monitor.start();
+    return monitor;
+}
+export function stopPerformanceMonitoring() {
+    if (performanceMonitor) {
+        performanceMonitor.stop();
+    }
+}
+export function recordServicePerformance(serviceName, operation, duration, success = true) {
+    if (performanceMonitor) {
+        performanceMonitor.recordServiceRequest(serviceName, duration, success);
+        logger.debug('Service performance recorded', {
+            service: serviceName,
+            operation,
+            duration,
+            success,
+        });
+    }
+}
+//# sourceMappingURL=performance-monitor.js.map

package/dist/core/providers.d.ts

@@ -0,0 +1,36 @@
+import { AIProvider } from './types';
+export interface ProviderInfo {
+    name: string;
+    description: string;
+    aliases: string[];
+    requiresApiKey: boolean;
+    defaultModel: string;
+    modelDescriptions?: Record<string, string>;
+    configHint?: string;
+}
+export declare const PROVIDER_DB: Record<AIProvider, ProviderInfo>;
+export declare const VALID_PROVIDERS: AIProvider[];
+export declare function getProviderDisplayName(provider: AIProvider): string;
+export declare function getProviderInfo(provider: AIProvider): ProviderInfo | undefined;
+export declare function findProviderByAlias(alias: string): AIProvider | null;
+export declare function levenshteinDistance(a: string, b: string): number;
+export declare function findSimilarProviders(input: string, threshold?: number): Array<{
+    provider: AIProvider;
+    similarity: number;
+    distance: number;
+}>;
+export declare function autoCorrectProvider(input: string): {
+    corrected: AIProvider | null;
+    original: string;
+    confidence: number;
+    suggestions: AIProvider[];
+};
+export declare function getDefaultConfigForProvider(provider: AIProvider): any;
+export declare function getAllProvidersForDisplay(): Array<{
+    id: AIProvider;
+    name: string;
+    description: string;
+    requiresKey: boolean;
+    defaultModel: string;
+}>;
+//# sourceMappingURL=providers.d.ts.map

package/dist/core/providers.js

@@ -0,0 +1,304 @@
+export const PROVIDER_DB = {
+    openai: {
+        name: 'OpenAI',
+        description: 'OpenAI GPT series models (ChatGPT, GPT-4, etc.)',
+        aliases: ['gpt', 'chatgpt', 'open-ai', 'openaai', 'openni'],
+        requiresApiKey: true,
+        defaultModel: 'gpt-4',
+        modelDescriptions: {
+            'gpt-4': 'Latest GPT-4, most capable',
+            'gpt-4-turbo': 'Balanced performance and cost',
+            'gpt-3.5-turbo': 'Fast response, low cost',
+            'gpt-4o': 'Multimodal support',
+            'gpt-4-mini': 'Lightweight version of GPT-4',
+        },
+        configHint: 'API key format: sk-xxx...',
+    },
+    anthropic: {
+        name: 'Anthropic',
+        description: 'Anthropic Claude models',
+        aliases: ['claude', 'anthropic-ai', 'claud'],
+        requiresApiKey: true,
+        defaultModel: 'claude-3-opus-20240229',
+        modelDescriptions: {
+            'claude-3-opus-20240229': 'Most capable',
+            'claude-3-sonnet-20240229': 'Balanced performance',
+            'claude-3-haiku-20240307': 'Fast response',
+        },
+        configHint: 'API key format: sk-ant-xxx...',
+    },
+    google: {
+        name: 'Google',
+        description: 'Google Gemini models',
+        aliases: ['gemini', 'google-ai', 'bard', 'palm'],
+        requiresApiKey: true,
+        defaultModel: 'gemini-pro',
+        modelDescriptions: {
+            'gemini-pro': 'General purpose model',
+            'gemini-pro-vision': 'Multimodal support',
+            'gemini-ultra': 'Most capable model',
+            'gemini-nano': 'Lightweight model',
+        },
+        configHint: 'API key format: AIza... (from Google AI Studio)',
+    },
+    azure: {
+        name: 'Azure',
+        description: 'Azure OpenAI services',
+        aliases: ['azure-openai', 'microsoft', 'azure-ai'],
+        requiresApiKey: true,
+        defaultModel: 'gpt-35-turbo',
+        modelDescriptions: {
+            'gpt-35-turbo': 'Azure version of GPT-3.5',
+            'gpt-4': 'Azure version of GPT-4',
+            'gpt-4-turbo': 'Azure version of GPT-4 Turbo',
+        },
+        configHint: 'Need Azure OpenAI endpoint and API key',
+    },
+    deepseek: {
+        name: 'DeepSeek',
+        description: 'DeepSeek open source models',
+        aliases: ['deep', 'ds', 'deep-seek', 'deepsek', 'deepseak'],
+        requiresApiKey: true,
+        defaultModel: 'deepseek-chat',
+        modelDescriptions: {
+            'deepseek-chat': 'Conversation optimized',
+            'deepseek-coder': 'Code generation optimized',
+            'deepseek-v3': 'Latest version',
+        },
+        configHint: 'API key format: sk-xxx or obtain from platform',
+    },
+    cohere: {
+        name: 'Cohere',
+        description: 'Cohere command models',
+        aliases: ['co', 'cohere-ai', 'coher'],
+        requiresApiKey: true,
+        defaultModel: 'command',
+        modelDescriptions: {
+            'command': 'General instruction model',
+            'command-r': 'Reasoning optimized',
+            'command-light': 'Lightweight version',
+        },
+    },
+    ollama: {
+        name: 'Ollama',
+        description: 'Local Ollama services',
+        aliases: ['oll', 'local-llm', 'llama', 'ollamaa', 'olama'],
+        requiresApiKey: false,
+        defaultModel: 'llama2',
+        modelDescriptions: {
+            'llama2': 'General model, balanced',
+            'llama3': 'Latest Llama 3',
+            'codellama': 'Code generation optimized',
+            'mistral': 'Small and efficient model',
+            'gemma': 'Google lightweight model',
+            'phi': 'Microsoft small model',
+        },
+        configHint: 'Ensure Ollama services are running at http://localhost:11434',
+    },
+    local: {
+        name: 'Local',
+        description: 'Local model files',
+        aliases: ['local-model', 'file', 'local-ai'],
+        requiresApiKey: false,
+        defaultModel: 'local-model',
+        configHint: 'Need to specify local model file path',
+    },
+    custom: {
+        name: 'Custom',
+        description: 'Custom API endpoints',
+        aliases: ['custom-api', 'self-hosted', 'custom-endpoint'],
+        requiresApiKey: false,
+        defaultModel: 'custom-model',
+        configHint: 'Need to specify API endpoint URL',
+    },
+    none: {
+        name: 'None',
+        description: 'No AI provider configured',
+        aliases: ['disabled', 'off', 'no-ai'],
+        requiresApiKey: false,
+        defaultModel: 'none',
+        configHint: 'AI functionality disabled',
+    },
+};
+export const VALID_PROVIDERS = Object.keys(PROVIDER_DB);
+// Get display names for all providers
+export function getProviderDisplayName(provider) {
+    return PROVIDER_DB[provider]?.name || provider;
+}
+// Get provider information
+export function getProviderInfo(provider) {
+    return PROVIDER_DB[provider];
+}
+// Find provider by alias
+export function findProviderByAlias(alias) {
+    const normalized = alias.toLowerCase().trim();
+    // Exact match
+    if (PROVIDER_DB[normalized]) {
+        return normalized;
+    }
+    // Alias match
+    for (const [provider, info] of Object.entries(PROVIDER_DB)) {
+        if (info.aliases.includes(normalized)) {
+            return provider;
+        }
+    }
+    return null;
+}
+// Calculate string similarity (Levenshtein distance)
+export function levenshteinDistance(a, b) {
+    const matrix = [];
+    for (let i = 0; i <= b.length; i++) {
+        matrix[i] = [i];
+    }
+    for (let j = 0; j <= a.length; j++) {
+        matrix[0][j] = j;
+    }
+    for (let i = 1; i <= b.length; i++) {
+        for (let j = 1; j <= a.length; j++) {
+            if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                matrix[i][j] = matrix[i - 1][j - 1];
+            }
+            else {
+                matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, // Replace
+                matrix[i][j - 1] + 1, // Insert
+                matrix[i - 1][j] + 1);
+            }
+        }
+    }
+    return matrix[b.length][a.length];
+}
+// Find most similar providers
+export function findSimilarProviders(input, threshold = 2) {
+    const normalized = input.toLowerCase().trim();
+    const results = [];
+    // Check all providers
+    for (const provider of VALID_PROVIDERS) {
+        // Calculate distance to provider name
+        const distanceToName = levenshteinDistance(normalized, provider);
+        // Calculate distance to alias
+        let minDistance = distanceToName;
+        const providerInfo = PROVIDER_DB[provider];
+        for (const alias of providerInfo.aliases) {
+            const distanceToAlias = levenshteinDistance(normalized, alias);
+            if (distanceToAlias < minDistance) {
+                minDistance = distanceToAlias;
+            }
+        }
+        // Convert to similarity percentage (distance 0 = 100%, decrease 25% for each additional distance)
+        const similarity = Math.max(0, 100 - minDistance * 25);
+        if (minDistance <= threshold) {
+            results.push({
+                provider,
+                similarity,
+                distance: minDistance,
+            });
+        }
+    }
+    // Sort by similarity
+    return results.sort((a, b) => {
+        // First sort by distance (smaller distance first)
+        if (a.distance !== b.distance) {
+            return a.distance - b.distance;
+        }
+        // Then sort by similarity (higher similarity first)
+        return b.similarity - a.similarity;
+    });
+}
+// Auto-correct provider name
+export function autoCorrectProvider(input) {
+    const normalized = input.toLowerCase().trim();
+    // 1. Exact match
+    if (PROVIDER_DB[normalized]) {
+        return {
+            corrected: normalized,
+            original: input,
+            confidence: 100,
+            suggestions: [],
+        };
+    }
+    // 2. Alias match
+    const aliasMatch = findProviderByAlias(normalized);
+    if (aliasMatch) {
+        return {
+            corrected: aliasMatch,
+            original: input,
+            confidence: 90,
+            suggestions: [],
+        };
+    }
+    // 3. Fuzzy match
+    const similar = findSimilarProviders(normalized, 3);
+    if (similar.length > 0) {
+        const bestMatch = similar[0];
+        const suggestions = similar.slice(1, 3).map(s => s.provider);
+        return {
+            corrected: bestMatch.provider,
+            original: input,
+            confidence: Math.max(30, bestMatch.similarity),
+            suggestions,
+        };
+    }
+    // 4. No match
+    return {
+        corrected: null,
+        original: input,
+        confidence: 0,
+        suggestions: [],
+    };
+}
+// Get default configuration for provider
+export function getDefaultConfigForProvider(provider) {
+    const info = PROVIDER_DB[provider];
+    if (!info) {
+        return null;
+    }
+    const baseConfig = {
+        provider,
+        model: info.defaultModel,
+    };
+    // Add specific provider default configuration
+    switch (provider) {
+        case 'ollama':
+            return {
+                ...baseConfig,
+                ollamaHost: 'http://localhost:11434',
+                timeout: 60000,
+                maxTokens: 4096,
+                temperature: 0.7,
+            };
+        case 'local':
+            return {
+                ...baseConfig,
+                localModelPath: '',
+                timeout: 120000,
+                maxTokens: 4096,
+                temperature: 0.7,
+            };
+        case 'custom':
+            return {
+                ...baseConfig,
+                apiEndpoint: 'http://localhost:8080/v1/chat/completions',
+                timeout: 30000,
+                maxTokens: 2048,
+                temperature: 0.7,
+            };
+        default:
+            return {
+                ...baseConfig,
+                timeout: 30000,
+                maxTokens: 2048,
+                temperature: 0.7,
+            };
+    }
+}
+// Get list of all providers (for display)
+export function getAllProvidersForDisplay() {
+    return VALID_PROVIDERS.map(provider => ({
+        id: provider,
+        name: PROVIDER_DB[provider].name,
+        description: PROVIDER_DB[provider].description,
+        requiresKey: PROVIDER_DB[provider].requiresApiKey,
+        defaultModel: PROVIDER_DB[provider].defaultModel,
+    }));
+}
+//# sourceMappingURL=providers.js.map