ai-debug-local-mcp/dist/utils/lazy-dependency-loader.js

🎯 ENHANCED AI GUIDANCE v4.1.2: Dramatically improved tool descriptions help AI users choose the right tools instead of 'close enough' options. Ultra-fast keyboard automation (10x speed), universal recording, multi-ecosystem debugging support, and compreh

/**
 * 🚀 Lazy Dependency Loader for AI-Debug
 *
 * Optimizes performance by loading heavy dependencies only when needed
 * Reduces startup time and memory usage significantly
 */
import { EventEmitter } from 'events';
export class LazyDependencyLoader extends EventEmitter {
    dependencies = new Map();
    loadingPromises = new Map();
    /**
     * Register a lazy-loaded dependency
     */
    register(name, loader) {
        let instance = null;
        let isLoaded = false;
        const dependency = {
            isLoaded: false,
            async load() {
                if (isLoaded && instance) {
                    return instance;
                }
                // Prevent multiple simultaneous loads
                if (this.loadingPromises.has(name)) {
                    return this.loadingPromises.get(name);
                }
                console.log(`🔄 Lazy loading dependency: ${name}`);
                const loadPromise = loader();
                this.loadingPromises.set(name, loadPromise);
                try {
                    instance = await loadPromise;
                    isLoaded = true;
                    dependency.isLoaded = true;
                    this.emit('loaded', name, instance);
                    console.log(`✅ Lazy loaded: ${name}`);
                    return instance;
                }
                catch (error) {
                    this.emit('error', name, error);
                    console.error(`❌ Failed to lazy load ${name}:`, error);
                    throw error;
                }
                finally {
                    this.loadingPromises.delete(name);
                }
            },
            get() {
                return instance;
            },
            unload() {
                if (instance && typeof instance.destroy === 'function') {
                    instance.destroy();
                }
                instance = null;
                isLoaded = false;
                dependency.isLoaded = false;
                console.log(`🗑️ Unloaded dependency: ${name}`);
                this.emit('unloaded', name);
            }
        };
        this.dependencies.set(name, dependency);
        return dependency;
    }
    /**
     * Get a registered dependency (will auto-load if needed)
     */
    async get(name) {
        const dependency = this.dependencies.get(name);
        if (!dependency) {
            throw new Error(`Dependency '${name}' not registered`);
        }
        return await dependency.load();
    }
    /**
     * Get dependency synchronously (returns null if not loaded)
     */
    getSync(name) {
        const dependency = this.dependencies.get(name);
        return dependency?.get() || null;
    }
    /**
     * Check if dependency is loaded
     */
    isLoaded(name) {
        return this.dependencies.get(name)?.isLoaded || false;
    }
    /**
     * Preload specific dependencies
     */
    async preload(names) {
        console.log(`🔄 Preloading dependencies: ${names.join(', ')}`);
        const startTime = performance.now();
        await Promise.all(names.map(name => this.get(name)));
        const duration = performance.now() - startTime;
        console.log(`✅ Preloaded ${names.length} dependencies in ${duration.toFixed(2)}ms`);
    }
    /**
     * Unload unused dependencies to free memory
     */
    cleanup() {
        for (const [name, dependency] of this.dependencies) {
            dependency.unload();
        }
        console.log('🧹 Cleaned up all lazy dependencies');
    }
    /**
     * Get loading statistics
     */
    getStats() {
        const total = this.dependencies.size;
        const loaded = Array.from(this.dependencies.values()).filter(d => d.isLoaded).length;
        const loading = this.loadingPromises.size;
        return {
            total,
            loaded,
            loading,
            unloaded: total - loaded
        };
    }
}
/**
 * Global lazy dependency manager
 */
export const lazyLoader = new LazyDependencyLoader();
/**
 * Common heavy dependencies registration
 */
export function registerCommonDependencies() {
    // Playwright - Heavy browser automation
    lazyLoader.register('playwright', async () => {
        const { chromium } = await import('playwright');
        return chromium;
    });
    // Sharp - Heavy image processing
    lazyLoader.register('sharp', async () => {
        const sharp = await import('sharp');
        return sharp.default;
    });
    // RobotJS - Heavy native automation (fallback)
    lazyLoader.register('robotjs', async () => {
        try {
            const robot = await import('robotjs');
            return robot;
        }
        catch (error) {
            console.warn('RobotJS not available, using fallbacks');
            return null;
        }
    });
    // Universal Screen Recorder - Heavy FFmpeg operations
    lazyLoader.register('universalRecorder', async () => {
        const { UniversalScreenRecorder } = await import('./universal-screen-recorder.js');
        return new UniversalScreenRecorder();
    });
    // Background Window Automation - Platform-specific
    lazyLoader.register('backgroundAutomation', async () => {
        const { BackgroundWindowAutomation } = await import('./background-window-automation.js');
        return new BackgroundWindowAutomation();
    });
    // Native Automation Executor - Platform-specific
    lazyLoader.register('nativeAutomation', async () => {
        const { NativeAutomationExecutor } = await import('./native-automation-executor.js');
        const executor = new NativeAutomationExecutor();
        await executor.initialize();
        return executor;
    });
}
/**
 * Framework-specific lazy loading
 */
export function registerFrameworkDependencies(frameworks) {
    if (frameworks.includes('flutter')) {
        lazyLoader.register('flutterDebugger', async () => {
            const { FlutterDebugEngine } = await import('../engines/flutter-debug-engine.js');
            return new FlutterDebugEngine();
        });
    }
    if (frameworks.includes('nextjs')) {
        lazyLoader.register('nextjsDebugger', async () => {
            const { NextJSDebugEngine } = await import('../engines/nextjs-debug-engine.js');
            return new NextJSDebugEngine();
        });
    }
    if (frameworks.includes('phoenix')) {
        lazyLoader.register('phoenixIntegration', async () => {
            const { PhoenixLiveViewIntegration } = await import('./phoenix-liveview-integration.js');
            return new PhoenixLiveViewIntegration();
        });
    }
}
//# sourceMappingURL=lazy-dependency-loader.js.map