versacompiler 2.0.0 → 2.0.2

package/dist/compiler/compile.js

@@ -1,7 +1,8 @@
+import { createHash } from 'node:crypto';
 import { glob, mkdir, readFile, stat, unlink, writeFile, } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { env } from 'node:process';
+import { argv, cwd, env, stdout } from 'node:process';
 // Lazy loading optimizations - Only import lightweight modules synchronously
 import { logger } from '../servicios/logger.js';
 import { promptUser } from '../utils/promptUser.js';
@@ -16,157 +17,267 @@ let generateTailwindCSS;
 let estandarizaCode;
 let preCompileTS;
 let preCompileVue;
-// 🚀 Sistema de Carga Inteligente de Módulos - VERSIÓN OPTIMIZADA
-class ModuleManager {
+// 🚀 Importar optimizador de transformaciones
+let TransformOptimizer;
+// 🚀 Importar optimizador de resolución de módulos
+let ModuleResolutionOptimizer;
+// 🚀 Sistema de Carga Inteligente de Módulos - VERSIÓN OPTIMIZADA V2
+class OptimizedModuleManager {
     static instance;
     isInitialized = false;
-    initializationPromise = null;
     loadedModules = new Set();
-    // NUEVOS: Gestión de modo y precarga
-    currentMode = null;
-    preloadPromises = new Map();
-    moduleCache = new Map();
-    constructor() { }
+    // ✨ NUEVAS OPTIMIZACIONES
+    modulePool = new Map(); // Pool de instancias reutilizables
+    loadingPromises = new Map(); // Prevenir cargas duplicadas
+    usageStats = new Map(); // Estadísticas de uso
+    preloadQueue = new Set(); // Cola de precarga
+    backgroundLoader = null; // Cargador en background
+    // Módulos críticos que siempre se precargan
+    HOT_MODULES = ['chalk', 'parser'];
+    // Contexto actual para optimizar cargas
+    currentContext = null;
+    constructor() {
+        // Iniciar precarga en background inmediatamente
+        this.startBackgroundPreloading();
+    }
     static getInstance() {
-        if (!ModuleManager.instance) {
-            ModuleManager.instance = new ModuleManager();
+        if (!OptimizedModuleManager.instance) {
+            OptimizedModuleManager.instance = new OptimizedModuleManager();
         }
-        return ModuleManager.instance;
+        return OptimizedModuleManager.instance;
     }
     /**
-     * NUEVO: Precarga estratégica para modo watch
+     * ✨ NUEVO: Precarga en background para módulos críticos
      */
-    async preloadForWatchMode() {
-        const essentialModules = ['chalk', 'parser', 'transforms'];
-        const preloadPromises = essentialModules.map(async (moduleName) => {
-            if (!this.loadedModules.has(moduleName)) {
-                switch (moduleName) {
-                    case 'chalk':
-                        return this._loadModule('chalk', loadChalk);
-                    case 'parser':
-                        return this._loadModule('parser', loadParser);
-                    case 'transforms':
-                        return this._loadModule('transforms', loadTransforms);
-                }
-            }
-        });
-        await Promise.all(preloadPromises);
-        // console.log('[ModuleManager] Precarga completada para modo watch');
-    } /**
-     * MEJORADO: Inicializa los módulos necesarios según el contexto de compilación
-     * @param context Contexto de compilación: 'individual', 'batch', 'watch'
-     * @param fileExtensions Extensiones de archivos a compilar para optimizar la carga
+    startBackgroundPreloading() {
+        this.backgroundLoader = this.preloadCriticalModules();
+    }
+    /**
+     * ✨ NUEVO: Precarga módulos críticos en background
      */
-    async initializeModules(context = 'individual', fileExtensions = new Set()) {
-        // Si cambia el contexto, reinicializar
-        if (this.currentMode !== context) {
-            this.currentMode = context;
-            // En modo watch, precargar módulos esenciales
-            if (context === 'watch') {
-                await this.preloadForWatchMode();
-            }
-        }
-        if (this.initializationPromise) {
-            return this.initializationPromise;
+    async preloadCriticalModules() {
+        try {
+            // Precargar módulos críticos de forma asíncrona
+            const preloadPromises = this.HOT_MODULES.map(moduleName => this.ensureModuleLoaded(moduleName).catch(() => {
+                // Silenciar errores de precarga, se intentará cargar después
+            }));
+            await Promise.allSettled(preloadPromises);
         }
-        if (this.isInitialized && context !== 'individual') {
-            return;
+        catch {
+            // Fallos en precarga no deben afectar la funcionalidad principal
         }
-        this.initializationPromise = this._performInitialization(context, fileExtensions);
-        await this.initializationPromise;
-        this.initializationPromise = null;
     }
-    async _performInitialization(context, fileExtensions) {
-        const modulesToLoad = [];
-        // Módulos siempre necesarios
-        if (!this.loadedModules.has('chalk')) {
-            modulesToLoad.push(this._loadModule('chalk', loadChalk));
-        }
-        if (!this.loadedModules.has('parser')) {
-            modulesToLoad.push(this._loadModule('parser', loadParser));
-        }
-        if (!this.loadedModules.has('transforms')) {
-            modulesToLoad.push(this._loadModule('transforms', loadTransforms));
+    /**
+     * ✨ MEJORADO: Precarga contextual basada en tipos de archivo
+     */
+    async preloadForContext(context, fileTypes = new Set()) {
+        this.currentContext = context;
+        // Esperar que termine la precarga crítica si está en progreso
+        if (this.backgroundLoader) {
+            await this.backgroundLoader;
         }
-        // Carga contextual según el tipo de compilación
+        const toPreload = []; // Precarga basada en contexto
         if (context === 'batch' || context === 'watch') {
-            // En modo batch/watch, precargar todos los módulos necesarios
-            if (!this.loadedModules.has('vue')) {
-                modulesToLoad.push(this._loadModule('vue', loadVue));
-            }
-            if (!this.loadedModules.has('typescript')) {
-                modulesToLoad.push(this._loadModule('typescript', loadTypeScript));
-            }
-            if (!this.loadedModules.has('minify')) {
-                modulesToLoad.push(this._loadModule('minify', loadMinify));
-            }
+            // En batch/watch, precargar todos los módulos comunes
+            toPreload.push('transforms', 'vue', 'typescript', 'module-resolution-optimizer');
         }
         else {
-            // En modo individual, cargar solo según las extensiones necesarias
-            if (fileExtensions.has('.vue') && !this.loadedModules.has('vue')) {
-                modulesToLoad.push(this._loadModule('vue', loadVue));
-            }
-            if ((fileExtensions.has('.ts') || fileExtensions.has('.vue')) &&
-                !this.loadedModules.has('typescript')) {
-                modulesToLoad.push(this._loadModule('typescript', loadTypeScript));
-            }
-            if (env.isPROD === 'true' && !this.loadedModules.has('minify')) {
-                modulesToLoad.push(this._loadModule('minify', loadMinify));
-            }
-        }
-        // Cargar módulos en paralelo
-        await Promise.all(modulesToLoad);
-        this.isInitialized = true;
-    }
-    async _loadModule(name, loadFunction) {
-        if (!this.loadedModules.has(name)) {
-            await loadFunction();
-            this.loadedModules.add(name);
+            // En individual, cargar solo según tipos de archivo detectados
+            if (fileTypes.has('.vue'))
+                toPreload.push('vue');
+            if (fileTypes.has('.ts') || fileTypes.has('.vue'))
+                toPreload.push('typescript');
+            if (!this.loadedModules.has('transforms'))
+                toPreload.push('transforms');
         }
+        // Precargar en paralelo
+        const preloadPromises = toPreload.map(moduleName => this.ensureModuleLoaded(moduleName).catch(() => {
+            // Log warning pero no fallar
+            console.warn(`Warning: No se pudo precargar módulo ${moduleName}`);
+        }));
+        await Promise.allSettled(preloadPromises);
     }
     /**
-     * Carga un módulo específico bajo demanda (lazy loading)
+     * ✨ MEJORADO: Carga inteligente con pooling y deduplicación
      */
     async ensureModuleLoaded(moduleName) {
-        if (this.loadedModules.has(moduleName)) {
-            return;
+        // 1. Verificar pool de módulos primero
+        if (this.modulePool.has(moduleName)) {
+            this.updateUsageStats(moduleName);
+            return this.modulePool.get(moduleName);
+        }
+        // 2. Verificar si ya está cargando (deduplicación)
+        if (this.loadingPromises.has(moduleName)) {
+            return this.loadingPromises.get(moduleName);
+        }
+        // 3. Iniciar carga
+        const loadPromise = this.loadModuleInternal(moduleName);
+        this.loadingPromises.set(moduleName, loadPromise);
+        try {
+            const moduleInstance = await loadPromise;
+            // 4. Almacenar en pool y estadísticas
+            this.modulePool.set(moduleName, moduleInstance);
+            this.loadedModules.add(moduleName);
+            this.updateUsageStats(moduleName);
+            return moduleInstance;
         }
+        finally {
+            // 5. Limpiar promesa de carga
+            this.loadingPromises.delete(moduleName);
+        }
+    }
+    /**
+     * ✨ NUEVO: Actualiza estadísticas de uso para optimizaciones futuras
+     */
+    updateUsageStats(moduleName) {
+        const currentCount = this.usageStats.get(moduleName) || 0;
+        this.usageStats.set(moduleName, currentCount + 1);
+    }
+    /**
+     * ✨ MEJORADO: Carga interna de módulos con mejor manejo de errores
+     */ async loadModuleInternal(moduleName) {
         switch (moduleName) {
+            case 'chalk':
+                return this.loadChalk();
+            case 'parser':
+                return this.loadParser();
+            case 'transforms':
+                return this.loadTransforms();
             case 'vue':
-                await this._loadModule('vue', loadVue);
-                break;
+                return this.loadVue();
             case 'typescript':
-                await this._loadModule('typescript', loadTypeScript);
-                break;
+                return this.loadTypeScript();
             case 'minify':
-                await this._loadModule('minify', loadMinify);
-                break;
+                return this.loadMinify();
             case 'tailwind':
-                await this._loadModule('tailwind', loadTailwind);
-                break;
+                return this.loadTailwind();
             case 'linter':
-                await this._loadModule('linter', loadLinter);
-                break;
+                return this.loadLinter();
+            case 'transform-optimizer':
+                return this.loadTransformOptimizer();
+            case 'module-resolution-optimizer':
+                return this.loadModuleResolutionOptimizer();
             default:
                 throw new Error(`Módulo desconocido: ${moduleName}`);
         }
     }
+    // ✨ Métodos de carga específicos optimizados
+    async loadChalk() {
+        if (!chalk) {
+            chalk = (await import('chalk')).default;
+        }
+        return chalk;
+    }
+    async loadParser() {
+        if (!getCodeFile) {
+            const parserModule = await import('./parser.js');
+            getCodeFile = parserModule.getCodeFile;
+        }
+        return getCodeFile;
+    }
+    async loadTransforms() {
+        if (!estandarizaCode) {
+            const transformsModule = await import('./transforms.js');
+            estandarizaCode = transformsModule.estandarizaCode;
+        }
+        return estandarizaCode;
+    }
+    async loadVue() {
+        if (!preCompileVue) {
+            const vueModule = await import('./vuejs.js');
+            preCompileVue = vueModule.preCompileVue;
+        }
+        return preCompileVue;
+    }
+    async loadTypeScript() {
+        if (!preCompileTS) {
+            const typescriptModule = await import('./typescript-manager.js');
+            preCompileTS = typescriptModule.preCompileTS;
+        }
+        return preCompileTS;
+    }
+    async loadMinify() {
+        if (!minifyJS) {
+            const minifyModule = await import('./minify.js');
+            minifyJS = minifyModule.minifyJS;
+        }
+        return minifyJS;
+    }
+    async loadTailwind() {
+        if (!generateTailwindCSS) {
+            const tailwindModule = await import('./tailwindcss.js');
+            generateTailwindCSS = tailwindModule.generateTailwindCSS;
+        }
+        return generateTailwindCSS;
+    }
+    async loadLinter() {
+        if (!ESLint || !OxLint) {
+            const linterModule = await import('./linter.js');
+            ESLint = linterModule.ESLint;
+            OxLint = linterModule.OxLint;
+        }
+        return { ESLint, OxLint };
+    }
+    async loadTransformOptimizer() {
+        if (!TransformOptimizer) {
+            const transformModule = await import('./transform-optimizer.js');
+            TransformOptimizer =
+                transformModule.TransformOptimizer.getInstance();
+        }
+        return TransformOptimizer;
+    }
+    async loadModuleResolutionOptimizer() {
+        if (!ModuleResolutionOptimizer) {
+            const resolutionModule = await import('./module-resolution-optimizer.js');
+            ModuleResolutionOptimizer =
+                resolutionModule.ModuleResolutionOptimizer.getInstance();
+        }
+        return ModuleResolutionOptimizer;
+    }
+    /**
+     * ✨ NUEVO: Obtiene estadísticas de performance del manager
+     */
+    getPerformanceStats() {
+        const sortedByUsage = Array.from(this.usageStats.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([name]) => name);
+        return {
+            loadedModules: Array.from(this.loadedModules),
+            usageStats: Object.fromEntries(this.usageStats),
+            poolSize: this.modulePool.size,
+            loadingInProgress: Array.from(this.loadingPromises.keys()),
+            mostUsedModules: sortedByUsage,
+        };
+    }
+    /**
+     * ✨ NUEVO: Limpia módulos no utilizados para liberar memoria
+     */
+    cleanupUnusedModules() {
+        const threshold = 1; // Mínimo de usos para mantener en pool
+        for (const [moduleName, usageCount] of this.usageStats) {
+            if (usageCount < threshold &&
+                !this.HOT_MODULES.includes(moduleName)) {
+                this.modulePool.delete(moduleName);
+                this.loadedModules.delete(moduleName);
+                this.usageStats.delete(moduleName);
+            }
+        }
+    }
     /**
      * Resetea el estado del manager (útil para tests)
      */
     reset() {
         this.isInitialized = false;
-        this.initializationPromise = null;
         this.loadedModules.clear();
-    }
-    /**
-     * Obtiene estadísticas de módulos cargados
-     */
-    getStats() {
-        return {
-            loaded: Array.from(this.loadedModules),
-            initialized: this.isInitialized,
-        };
+        this.modulePool.clear();
+        this.loadingPromises.clear();
+        this.usageStats.clear();
+        this.preloadQueue.clear();
+        this.currentContext = null;
+        this.backgroundLoader = null;
+        // Reiniciar precarga crítica
+        this.startBackgroundPreloading();
     }
 }
 // Lazy loading helper functions
@@ -214,7 +325,7 @@ async function loadTransforms() {
 }
 async function loadTypeScript() {
     if (!preCompileTS) {
-        const typescriptModule = await import('./typescript.js');
+        const typescriptModule = await import('./typescript-manager.js');
         preCompileTS = typescriptModule.preCompileTS;
     }
     return preCompileTS;
@@ -229,40 +340,531 @@ async function loadVue() {
 // Almacenamiento global de errores y resultados
 const compilationErrors = [];
 const compilationResults = [];
-const compilationCache = new Map();
-const CACHE_DIR = path.join(path.resolve(env.PATH_PROY || process.cwd(), 'compiler'), '.cache');
-const CACHE_FILE = path.join(CACHE_DIR, 'versacompile-cache.json');
-async function loadCache() {
-    try {
-        if (env.cleanCache === 'true') {
-            compilationCache.clear();
+// Variables de entorno relevantes para compilación
+const COMPILATION_ENV_VARS = [
+    'NODE_ENV',
+    'isPROD',
+    'TAILWIND',
+    'ENABLE_LINTER',
+    'VERBOSE',
+    'typeCheck',
+    'PATH_ALIAS',
+    'tailwindcss',
+    'linter',
+    'tsconfigFile',
+];
+class SmartCompilationCache {
+    cache = new Map();
+    maxEntries = 500; // Máximo archivos en cache
+    maxMemory = 100 * 1024 * 1024; // 100MB límite
+    currentMemoryUsage = 0;
+    // ✨ ISSUE #3: Sistema de vigilancia de dependencias
+    fileWatchers = new Map(); // chokidar watchers
+    dependencyGraph = new Map(); // archivo -> dependencias
+    reverseDependencyGraph = new Map(); // dependencia -> archivos que la usan
+    packageJsonPath = path.join(cwd(), 'package.json');
+    nodeModulesPath = path.join(cwd(), 'node_modules');
+    isWatchingDependencies = false;
+    /**
+     * Genera hash SHA-256 del contenido del archivo
+     */ async generateContentHash(filePath) {
+        try {
+            const content = await readFile(filePath, 'utf8');
+            return createHash('sha256').update(content).digest('hex');
+        }
+        catch {
+            // Si no se puede leer el archivo, generar hash único basado en la ruta y timestamp
+            const fallback = `${filePath}-${Date.now()}`;
+            return createHash('sha256').update(fallback).digest('hex');
+        }
+    }
+    /**
+     * Genera hash de la configuración del compilador
+     */
+    generateConfigHash() {
+        try {
+            // Recopilar configuración relevante de variables de entorno
+            const config = {
+                isPROD: env.isPROD || 'false',
+                TAILWIND: env.TAILWIND || 'false',
+                ENABLE_LINTER: env.ENABLE_LINTER || 'false',
+                PATH_ALIAS: env.PATH_ALIAS || '{}',
+                tailwindcss: env.tailwindcss || 'false',
+                linter: env.linter || 'false',
+                tsconfigFile: env.tsconfigFile || './tsconfig.json',
+            };
+            const configStr = JSON.stringify(config, Object.keys(config).sort());
+            return createHash('sha256')
+                .update(configStr)
+                .digest('hex')
+                .substring(0, 12);
+        }
+        catch {
+            return 'no-config';
+        }
+    }
+    /**
+     * Genera hash de variables de entorno relevantes
+     */
+    generateEnvHash() {
+        try {
+            const envVars = COMPILATION_ENV_VARS.map(key => `${key}=${env[key] || ''}`).join('|');
+            return createHash('sha256')
+                .update(envVars)
+                .digest('hex')
+                .substring(0, 12);
+        }
+        catch {
+            return 'no-env';
+        }
+    } /**
+     * ✨ ISSUE #3: Genera hash avanzado de dependencias del proyecto
+     * Incluye vigilancia de package.json, node_modules y versiones instaladas
+     */
+    async generateDependencyHash() {
+        try {
+            const hash = createHash('sha256');
+            // 1. Hash del package.json con versiones
+            const packagePath = path.join(cwd(), 'package.json');
+            const packageContent = await readFile(packagePath, 'utf8');
+            const pkg = JSON.parse(packageContent);
+            const deps = {
+                ...pkg.dependencies,
+                ...pkg.devDependencies,
+            };
+            const depsStr = JSON.stringify(deps, Object.keys(deps).sort());
+            hash.update(`package:${depsStr}`);
+            // 2. Hash del package-lock.json si existe (versiones exactas instaladas)
             try {
-                await unlink(CACHE_FILE);
+                const lockPath = path.join(cwd(), 'package-lock.json');
+                const lockContent = await readFile(lockPath, 'utf8');
+                const lockData = JSON.parse(lockContent);
+                // Solo incluir las versiones instaladas, no todo el lockfile
+                const installedVersions = {};
+                if (lockData.packages) {
+                    for (const [pkgPath, pkgInfo] of Object.entries(lockData.packages)) {
+                        if (pkgPath &&
+                            pkgPath !== '' &&
+                            typeof pkgInfo === 'object' &&
+                            pkgInfo !== null) {
+                            const pkgName = pkgPath.replace('node_modules/', '');
+                            if (pkgInfo.version) {
+                                installedVersions[pkgName] = pkgInfo.version;
+                            }
+                        }
+                    }
+                }
+                hash.update(`lock:${JSON.stringify(installedVersions, Object.keys(installedVersions).sort())}`);
             }
             catch {
-                // Ignorar errores al eliminar el archivo
+                // Ignorar si no existe package-lock.json
             }
+            // 3. ✨ NUEVO: Hash de timestamps críticos de node_modules
+            try {
+                const nodeModulesPath = path.join(cwd(), 'node_modules');
+                const nodeModulesStat = await stat(nodeModulesPath);
+                hash.update(`nmtime:${nodeModulesStat.mtimeMs}`);
+                // Verificar timestamps de dependencias críticas instaladas
+                const criticalDeps = Object.keys(deps).slice(0, 10); // Top 10 para performance
+                for (const dep of criticalDeps) {
+                    try {
+                        const depPath = path.join(nodeModulesPath, dep);
+                        const depStat = await stat(depPath);
+                        hash.update(`${dep}:${depStat.mtimeMs}`);
+                    }
+                    catch {
+                        // Dependencia no instalada o error
+                        hash.update(`${dep}:missing`);
+                    }
+                }
+            }
+            catch {
+                // node_modules no existe
+                hash.update('nmtime:none');
+            }
+            return hash.digest('hex').substring(0, 16);
         }
-        const cacheData = await readFile(CACHE_FILE, 'utf-8');
-        const parsed = JSON.parse(cacheData);
-        for (const [key, value] of Object.entries(parsed)) {
-            compilationCache.set(key, value);
+        catch (error) {
+            // Incluir información del error en el hash para debugging
+            return createHash('sha256')
+                .update(`error:${error instanceof Error ? error.message : 'unknown'}`)
+                .digest('hex')
+                .substring(0, 16);
         }
     }
-    catch {
-        // Cache file doesn't exist or is invalid, start fresh
+    /**
+     * Genera clave de cache granular que incluye todos los factores
+     */
+    async generateCacheKey(filePath) {
+        const contentHash = await this.generateContentHash(filePath);
+        const configHash = this.generateConfigHash();
+        const envHash = this.generateEnvHash();
+        const dependencyHash = await this.generateDependencyHash();
+        // Usar | como separador para evitar problemas con rutas de Windows
+        return `${filePath}|${contentHash.substring(0, 12)}|${configHash}|${envHash}|${dependencyHash}`;
+    } /**
+     * Verifica si una entrada de cache es válida
+     */
+    async isValid(filePath) {
+        const entry = this.cache.get(filePath);
+        if (!entry)
+            return false;
+        try {
+            // Verificar si el archivo de salida existe
+            await stat(entry.outputPath);
+            // Verificar si el contenido ha cambiado
+            const currentContentHash = await this.generateContentHash(filePath);
+            if (entry.contentHash !== currentContentHash) {
+                this.cache.delete(filePath);
+                return false;
+            }
+            // Verificar si la configuración ha cambiado
+            const currentConfigHash = this.generateConfigHash();
+            if (entry.configHash !== currentConfigHash) {
+                this.cache.delete(filePath);
+                return false;
+            }
+            // Verificar si las variables de entorno han cambiado
+            const currentEnvHash = this.generateEnvHash();
+            if (entry.envHash !== currentEnvHash) {
+                this.cache.delete(filePath);
+                return false;
+            }
+            // Verificar si las dependencias han cambiado
+            const currentDependencyHash = await this.generateDependencyHash();
+            if (entry.dependencyHash !== currentDependencyHash) {
+                this.cache.delete(filePath);
+                return false;
+            }
+            // Verificar tiempo de modificación como backup
+            const stats = await stat(filePath);
+            if (stats.mtimeMs > entry.mtime) {
+                this.cache.delete(filePath);
+                return false;
+            }
+            // Actualizar tiempo de uso para LRU
+            entry.lastUsed = Date.now();
+            return true;
+        }
+        catch {
+            // Si hay error verificando, eliminar del cache
+            this.cache.delete(filePath);
+            return false;
+        }
+    } /**
+     * Añade una entrada al cache
+     */
+    async set(filePath, outputPath) {
+        try {
+            const stats = await stat(filePath);
+            const contentHash = await this.generateContentHash(filePath);
+            const configHash = this.generateConfigHash();
+            const envHash = this.generateEnvHash();
+            const dependencyHash = await this.generateDependencyHash();
+            const entry = {
+                contentHash,
+                configHash,
+                envHash,
+                dependencyHash,
+                mtime: stats.mtimeMs,
+                outputPath,
+                lastUsed: Date.now(),
+                size: stats.size,
+            };
+            // Aplicar límites de memoria y entradas antes de agregar
+            this.evictIfNeeded(entry.size);
+            this.cache.set(filePath, entry);
+            this.currentMemoryUsage += entry.size;
+        }
+        catch (error) {
+            // Si hay error, no cachear
+            console.warn(`Warning: No se pudo cachear ${filePath}:`, error);
+        }
     }
-}
-async function saveCache() {
-    try {
-        await mkdir(CACHE_DIR, { recursive: true });
-        const cacheData = Object.fromEntries(compilationCache);
-        await writeFile(CACHE_FILE, JSON.stringify(cacheData, null, 2));
+    /**
+     * Aplica política LRU para liberar espacio
+     */
+    evictIfNeeded(newEntrySize) {
+        // Verificar límite de entradas
+        while (this.cache.size >= this.maxEntries) {
+            this.evictLRU();
+        }
+        // Verificar límite de memoria
+        while (this.currentMemoryUsage + newEntrySize > this.maxMemory &&
+            this.cache.size > 0) {
+            this.evictLRU();
+        }
+    }
+    /**
+     * Elimina la entrada menos recientemente usada
+     */
+    evictLRU() {
+        let oldestKey = '';
+        let oldestTime = Infinity;
+        for (const [key, entry] of this.cache) {
+            if (entry.lastUsed < oldestTime) {
+                oldestTime = entry.lastUsed;
+                oldestKey = key;
+            }
+        }
+        if (oldestKey) {
+            const entry = this.cache.get(oldestKey);
+            if (entry) {
+                this.currentMemoryUsage -= entry.size;
+                this.cache.delete(oldestKey);
+            }
+        }
+    }
+    /**
+     * Carga el cache desde disco
+     */
+    async load(cacheFile) {
+        try {
+            if (env.cleanCache === 'true') {
+                this.cache.clear();
+                this.currentMemoryUsage = 0;
+                try {
+                    await unlink(cacheFile);
+                }
+                catch {
+                    // Ignorar errores al eliminar el archivo
+                }
+                return;
+            }
+            const cacheData = await readFile(cacheFile, 'utf-8');
+            const parsed = JSON.parse(cacheData);
+            // Validar y cargar entradas del cache
+            for (const [key, value] of Object.entries(parsed)) {
+                const entry = value;
+                if (entry.contentHash && entry.outputPath && entry.mtime) {
+                    this.cache.set(key, entry);
+                    this.currentMemoryUsage += entry.size || 0;
+                }
+            }
+        }
+        catch {
+            // Cache file doesn't exist or is invalid, start fresh
+            this.cache.clear();
+            this.currentMemoryUsage = 0;
+        }
+    }
+    /**
+     * Guarda el cache a disco
+     */
+    async save(cacheFile, cacheDir) {
+        try {
+            await mkdir(cacheDir, { recursive: true });
+            const cacheData = Object.fromEntries(this.cache);
+            await writeFile(cacheFile, JSON.stringify(cacheData, null, 2));
+        }
+        catch (error) {
+            console.warn('Warning: No se pudo guardar el cache:', error);
+        }
     }
-    catch {
-        // Ignore save errors
+    /**
+     * Limpia completamente el cache
+     */
+    clear() {
+        this.cache.clear();
+        this.currentMemoryUsage = 0;
+    } /**
+     * Obtiene la ruta de salida para un archivo cacheado
+     */
+    getOutputPath(filePath) {
+        const entry = this.cache.get(filePath);
+        return entry?.outputPath || '';
+    } /**
+     * Obtiene estadísticas del cache
+     */
+    getStats() {
+        return {
+            entries: this.cache.size,
+            memoryUsage: this.currentMemoryUsage,
+            hitRate: 0, // Se calculará externamente
+        };
+    }
+    // ✨ ISSUE #3: Métodos de vigilancia y invalidación cascada
+    /**
+     * Inicializa vigilancia de package.json y node_modules
+     */
+    async startDependencyWatching() {
+        if (this.isWatchingDependencies)
+            return;
+        try {
+            // Lazy load chokidar para evitar problemas de importación
+            const chokidar = await import('chokidar');
+            // Vigilar package.json
+            if (await this.fileExists(this.packageJsonPath)) {
+                const packageWatcher = chokidar.watch(this.packageJsonPath, {
+                    persistent: false, // No mantener el proceso vivo
+                    ignoreInitial: true,
+                });
+                packageWatcher.on('change', () => {
+                    logger.info('📦 package.json modificado - invalidando cache de dependencias');
+                    this.invalidateByDependencyChange();
+                });
+                this.fileWatchers.set('package.json', packageWatcher);
+            }
+            // Vigilar node_modules (solo cambios en el directorio raíz para performance)
+            if (await this.fileExists(this.nodeModulesPath)) {
+                const nodeModulesWatcher = chokidar.watch(this.nodeModulesPath, {
+                    persistent: false,
+                    ignoreInitial: true,
+                    depth: 1, // Solo primer nivel para performance
+                    ignored: /(^|[\/\\])\../, // Ignorar archivos ocultos
+                });
+                nodeModulesWatcher.on('addDir', (path) => {
+                    logger.info(`📦 Nueva dependencia instalada: ${path.split(/[/\\]/).pop()}`);
+                    this.invalidateByDependencyChange();
+                });
+                nodeModulesWatcher.on('unlinkDir', (path) => {
+                    logger.info(`📦 Dependencia eliminada: ${path.split(/[/\\]/).pop()}`);
+                    this.invalidateByDependencyChange();
+                });
+                this.fileWatchers.set('node_modules', nodeModulesWatcher);
+            }
+            this.isWatchingDependencies = true;
+            logger.info('🔍 Vigilancia de dependencias iniciada');
+        }
+        catch (error) {
+            logger.warn('⚠️ No se pudo iniciar vigilancia de dependencias:', error);
+        }
+    }
+    /**
+     * Detiene la vigilancia de dependencias
+     */
+    async stopDependencyWatching() {
+        for (const [name, watcher] of this.fileWatchers) {
+            try {
+                await watcher.close();
+                logger.info(`🛑 Vigilancia detenida: ${name}`);
+            }
+            catch (error) {
+                logger.warn(`⚠️ Error cerrando watcher ${name}:`, error);
+            }
+        }
+        this.fileWatchers.clear();
+        this.isWatchingDependencies = false;
+    }
+    /**
+     * Registra dependencias de un archivo para invalidación cascada
+     */
+    registerDependencies(filePath, dependencies) {
+        // Limpiar dependencias anteriores
+        const oldDeps = this.dependencyGraph.get(filePath);
+        if (oldDeps) {
+            for (const dep of oldDeps) {
+                const reverseDeps = this.reverseDependencyGraph.get(dep);
+                if (reverseDeps) {
+                    reverseDeps.delete(filePath);
+                    if (reverseDeps.size === 0) {
+                        this.reverseDependencyGraph.delete(dep);
+                    }
+                }
+            }
+        }
+        // Registrar nuevas dependencias
+        const newDeps = new Set(dependencies);
+        this.dependencyGraph.set(filePath, newDeps);
+        for (const dep of newDeps) {
+            if (!this.reverseDependencyGraph.has(dep)) {
+                this.reverseDependencyGraph.set(dep, new Set());
+            }
+            this.reverseDependencyGraph.get(dep).add(filePath);
+        }
+    }
+    /**
+     * Invalida cache por cambios en dependencias
+     */
+    invalidateByDependencyChange() {
+        let invalidatedCount = 0;
+        // Invalidar todos los archivos que dependen de dependencias externas
+        for (const [filePath] of this.cache) {
+            this.cache.delete(filePath);
+            invalidatedCount++;
+        }
+        // Limpiar grafos de dependencias
+        this.dependencyGraph.clear();
+        this.reverseDependencyGraph.clear();
+        this.currentMemoryUsage = 0;
+        logger.info(`🗑️ Cache invalidado: ${invalidatedCount} archivos (cambio en dependencias)`);
+    }
+    /**
+     * Invalida cascada cuando un archivo específico cambia
+     */
+    invalidateCascade(changedFile) {
+        const invalidated = [];
+        const toInvalidate = new Set([changedFile]);
+        // BFS para encontrar todos los archivos afectados
+        const queue = [changedFile];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            const dependents = this.reverseDependencyGraph.get(current);
+            if (dependents) {
+                for (const dependent of dependents) {
+                    if (!toInvalidate.has(dependent)) {
+                        toInvalidate.add(dependent);
+                        queue.push(dependent);
+                    }
+                }
+            }
+        }
+        // Invalidar archivos
+        for (const filePath of toInvalidate) {
+            if (this.cache.has(filePath)) {
+                const entry = this.cache.get(filePath);
+                this.currentMemoryUsage -= entry.size;
+                this.cache.delete(filePath);
+                invalidated.push(filePath);
+            }
+        }
+        if (invalidated.length > 0) {
+            logger.info(`🔄 Invalidación cascada: ${invalidated.length} archivos afectados por ${changedFile}`);
+        }
+        return invalidated;
+    }
+    /**
+     * Verifica si un archivo existe
+     */
+    async fileExists(filePath) {
+        try {
+            await stat(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Obtiene estadísticas avanzadas del cache
+     */
+    getAdvancedStats() {
+        return {
+            entries: this.cache.size,
+            memoryUsage: this.currentMemoryUsage,
+            hitRate: 0,
+            dependencyNodes: this.dependencyGraph.size,
+            watchingDependencies: this.isWatchingDependencies,
+            activeWatchers: this.fileWatchers.size,
+        };
     }
 }
+// Instancia global del cache inteligente
+const smartCache = new SmartCompilationCache();
+const CACHE_DIR = path.join(path.resolve(env.PATH_PROY || cwd(), 'compiler'), '.cache');
+const CACHE_FILE = path.join(CACHE_DIR, 'versacompile-cache.json');
+async function loadCache() {
+    await smartCache.load(CACHE_FILE);
+    // ✨ ISSUE #3: Iniciar vigilancia de dependencias en modo watch
+    if (env.WATCH_MODE === 'true' ||
+        argv.includes('--watch') ||
+        argv.includes('-w')) {
+        await smartCache.startDependencyWatching();
+    }
+}
+async function saveCache() {
+    await smartCache.save(CACHE_FILE, CACHE_DIR);
+}
 // 🎯 Funciones del Sistema Unificado de Manejo de Errores
 /**
  * Registra un error de compilación en el sistema unificado
@@ -551,10 +1153,10 @@ class WatchModeOptimizer {
                     if (cached && cached.mtime >= stats.mtimeMs) {
                         resolve({ success: true, cached: true });
                         return;
-                    } // Configurar worker para modo watch
-                    const { TypeScriptWorkerManager } = await import('./typescript-worker.js');
-                    const workerManager = TypeScriptWorkerManager.getInstance();
-                    workerManager.setMode('watch');
+                    } // Configurar worker pool para modo watch
+                    const { TypeScriptWorkerPool } = await import('./typescript-worker-pool.js');
+                    const workerPool = TypeScriptWorkerPool.getInstance();
+                    workerPool.setMode('watch');
                     const result = await compileFn(filePath);
                     this.fileSystemCache.set(filePath, {
                         mtime: stats.mtimeMs,
@@ -579,9 +1181,8 @@ async function compileJS(inPath, outPath, mode = 'individual') {
     // Si la ruta ya es absoluta, no la resolvamos de nuevo
     inPath = path.isAbsolute(inPath)
         ? normalizeRuta(inPath)
-        : normalizeRuta(path.resolve(inPath));
-    // 🚀 Usar ModuleManager para carga optimizada
-    const moduleManager = ModuleManager.getInstance();
+        : normalizeRuta(path.resolve(inPath)); // 🚀 Usar OptimizedModuleManager para carga optimizada
+    const moduleManager = OptimizedModuleManager.getInstance();
     // Timing de lectura
     let start = Date.now();
     const extension = path.extname(inPath);
@@ -729,9 +1330,6 @@ async function compileJS(inPath, outPath, mode = 'individual') {
     const destinationDir = path.dirname(outPath);
     await mkdir(destinationDir, { recursive: true });
     await writeFile(outPath, code, 'utf-8');
-    if (env.VERBOSE === 'true') {
-        logger.info(`\n📊 Timings para ${path.basename(inPath)}:`, JSON.stringify(timings));
-    }
     return {
         error: null,
         action: 'extension',
@@ -740,11 +1338,11 @@ async function compileJS(inPath, outPath, mode = 'individual') {
 export async function initCompile(ruta, compileTailwind = true, mode = 'individual') {
     try {
         // 🚀 Sistema de Carga Inteligente de Módulos
-        const moduleManager = ModuleManager.getInstance();
+        const moduleManager = OptimizedModuleManager.getInstance();
         const fileExtension = path.extname(ruta);
         const fileExtensions = new Set([fileExtension]);
         // Inicializar módulos según el contexto
-        await moduleManager.initializeModules(mode === 'all' ? 'batch' : mode, fileExtensions);
+        await moduleManager.preloadForContext(mode === 'all' ? 'batch' : mode, fileExtensions);
         // Generar TailwindCSS si está habilitado
         if (compileTailwind && Boolean(env.TAILWIND)) {
             await moduleManager.ensureModuleLoaded('tailwind');
@@ -950,28 +1548,7 @@ function createProgressBar(current, total, width = 30) {
 }
 // Función helper para verificar si un archivo debe ser omitido por cache
 async function shouldSkipFile(filePath) {
-    try {
-        const stats = await stat(filePath);
-        const cacheEntry = compilationCache.get(filePath);
-        if (!cacheEntry) {
-            return false; // No hay entrada en cache, debe compilarse
-        }
-        // Verificar si el archivo no ha cambiado desde la última compilación
-        if (stats.mtimeMs <= cacheEntry.mtime) {
-            // Verificar si el archivo de salida existe
-            try {
-                await stat(cacheEntry.outputPath);
-                return true; // Archivo existe y no ha cambiado, se puede omitir
-            }
-            catch {
-                return false; // Archivo de salida no existe, debe recompilarse
-            }
-        }
-        return false; // Archivo ha cambiado, debe recompilarse
-    }
-    catch {
-        return false; // Error al verificar, compilar por seguridad
-    }
+    return await smartCache.isValid(filePath);
 }
 // Función para compilar archivos con límite de concurrencia
 async function compileWithConcurrencyLimit(files, maxConcurrency = 8) {
@@ -987,7 +1564,7 @@ async function compileWithConcurrencyLimit(files, maxConcurrency = 8) {
         const progressPercent = Math.round((currentTotal / total) * 100);
         if (progressPercent > lastProgressUpdate + 1 ||
             currentTotal === total) {
-            process.stdout.write(`\r🚀 ${progressBar} [✅ ${completed} | ⏭️ ${skipped} | ❌ ${failed}]`);
+            stdout.write(`\r🚀 ${progressBar} [✅ ${completed} | ⏭️ ${skipped} | ❌ ${failed}]`);
             lastProgressUpdate = progressPercent;
         }
     }
@@ -1001,18 +1578,12 @@ async function compileWithConcurrencyLimit(files, maxConcurrency = 8) {
                     return {
                         success: true,
                         cached: true,
-                        output: compilationCache.get(file)?.outputPath || '',
+                        output: smartCache.getOutputPath(file),
                     };
                 }
-                const result = await initCompile(file, false, 'batch');
-                // Actualizar cache si la compilación fue exitosa
+                const result = await initCompile(file, false, 'batch'); // Actualizar cache si la compilación fue exitosa
                 if (result.success && result.output) {
-                    const stats = await stat(file);
-                    compilationCache.set(file, {
-                        hash: '', // Se podría implementar hash del contenido si es necesario
-                        mtime: stats.mtimeMs,
-                        outputPath: result.output,
-                    });
+                    await smartCache.set(file, result.output);
                 }
                 completed++;
                 showProgress();
@@ -1094,7 +1665,15 @@ export async function initCompileAll() {
         else {
             maxConcurrency = Math.min(cpuCount * 2, 16);
         }
-        logger.info(`🚀 Compilando ${fileCount} archivos con concurrencia optimizada (${maxConcurrency} hilos)...`);
+        logger.info(`🚀 Compilando ${fileCount} archivos con concurrencia optimizada (${maxConcurrency} hilos)...`); // Configurar worker pool para modo batch
+        try {
+            const { TypeScriptWorkerPool } = await import('./typescript-worker-pool.js');
+            const workerPool = TypeScriptWorkerPool.getInstance();
+            workerPool.setMode('batch');
+        }
+        catch {
+            // Error silencioso en configuración del pool
+        }
         await compileWithConcurrencyLimit(filesToCompile, maxConcurrency);
         // Guardar cache al final
         await saveCache();