versacompiler 2.0.1 → 2.0.3

package/dist/compiler/compile.js

@@ -2,11 +2,13 @@ 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 { cwd, env, stdout } from 'node:process';
+import process, { argv, cwd, env } from 'node:process';
 // Lazy loading optimizations - Only import lightweight modules synchronously
-import { logger } from '../servicios/logger.js';
+import { logger, setProgressManagerGetter } from '../servicios/logger.js';
 import { promptUser } from '../utils/promptUser.js';
 import { showTimingForHumans } from '../utils/utils.js';
+// Configurar el getter del ProgressManager para el logger
+setProgressManagerGetter(() => ProgressManager.getInstance());
 // Heavy dependencies will be loaded dynamically when needed
 let chalk;
 let ESLint;
@@ -340,11 +342,31 @@ async function loadVue() {
 // Almacenamiento global de errores y resultados
 const compilationErrors = [];
 const compilationResults = [];
+// 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
+    maxEntries = 200; // Reducido para tests de estrés
+    maxMemory = 50 * 1024 * 1024; // 50MB límite (reducido)
     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) {
@@ -359,6 +381,130 @@ class SmartCompilationCache {
         }
     }
     /**
+     * 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 {
+                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 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);
+        }
+        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);
+        }
+    }
+    /**
+     * 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) {
@@ -369,8 +515,26 @@ class SmartCompilationCache {
             // Verificar si el archivo de salida existe
             await stat(entry.outputPath);
             // Verificar si el contenido ha cambiado
-            const currentHash = await this.generateContentHash(filePath);
-            if (entry.contentHash !== currentHash) {
+            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;
             }
@@ -389,16 +553,21 @@ class SmartCompilationCache {
             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(),
@@ -413,22 +582,31 @@ class SmartCompilationCache {
             // Si hay error, no cachear
             console.warn(`Warning: No se pudo cachear ${filePath}:`, error);
         }
-    }
-    /**
+    } /**
      * Aplica política LRU para liberar espacio
      */
     evictIfNeeded(newEntrySize) {
-        // Verificar límite de entradas
-        while (this.cache.size >= this.maxEntries) {
+        // Verificar límite de entradas más agresivamente
+        while (this.cache.size >= this.maxEntries * 0.8) {
+            // Limpiar cuando llegue al 80%
             this.evictLRU();
         }
-        // Verificar límite de memoria
-        while (this.currentMemoryUsage + newEntrySize > this.maxMemory &&
+        // Verificar límite de memoria más agresivamente
+        while (this.currentMemoryUsage + newEntrySize > this.maxMemory * 0.8 && // Limpiar cuando llegue al 80%
             this.cache.size > 0) {
             this.evictLRU();
         }
-    }
-    /**
+        // Eviction adicional si la memoria total del proceso es alta
+        const memUsage = process.memoryUsage();
+        const heapUsedMB = memUsage.heapUsed / (1024 * 1024);
+        if (heapUsedMB > 200 && this.cache.size > 50) {
+            // Si heap > 200MB, limpiar más agresivamente
+            const entriesToRemove = Math.min(this.cache.size - 50, 10);
+            for (let i = 0; i < entriesToRemove; i++) {
+                this.evictLRU();
+            }
+        }
+    } /**
      * Elimina la entrada menos recientemente usada
      */
     evictLRU() {
@@ -448,6 +626,23 @@ class SmartCompilationCache {
             }
         }
     }
+    /**
+     * Método público para limpiar entradas del cache cuando sea necesario
+     */
+    cleanOldEntries(maxEntriesToRemove = 20) {
+        let removedCount = 0;
+        for (let i = 0; i < maxEntriesToRemove && this.cache.size > 0; i++) {
+            const sizeBefore = this.cache.size;
+            this.evictLRU();
+            if (this.cache.size < sizeBefore) {
+                removedCount++;
+            }
+            else {
+                break; // No se pudo remover más entradas
+            }
+        }
+        return removedCount;
+    }
     /**
      * Carga el cache desde disco
      */
@@ -506,8 +701,7 @@ class SmartCompilationCache {
     getOutputPath(filePath) {
         const entry = this.cache.get(filePath);
         return entry?.outputPath || '';
-    }
-    /**
+    } /**
      * Obtiene estadísticas del cache
      */
     getStats() {
@@ -517,6 +711,171 @@ class SmartCompilationCache {
             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();
@@ -524,6 +883,12 @@ const CACHE_DIR = path.join(path.resolve(env.PATH_PROY || cwd(), 'compiler'), '.
 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);
@@ -615,28 +980,42 @@ function clearCompilationState() {
 /**
  * Muestra un resumen detallado de todos los errores de compilación
  */
-async function displayCompilationSummary(isVerbose = false) {
+async function displayCompilationSummary(isVerbose = false, totalTime) {
     const chalk = await loadChalk();
     if (compilationErrors.length === 0 && compilationResults.length === 0) {
         logger.info(chalk.green('✅ No hay errores de compilación para mostrar.'));
+        if (totalTime) {
+            logger.info(chalk.bold(`\n⏱️ TIEMPO TOTAL DE COMPILACIÓN: ${totalTime}`));
+        }
         return;
     }
-    logger.info(chalk.bold('\n--- 📊 RESUMEN DE COMPILACIÓN ---'));
-    // Mostrar estadísticas por etapa
+    // 🎨 Header moderno del resumen
+    const summaryLine = '━'.repeat(40);
+    logger.info('');
+    logger.info(chalk.bold.cyan('📊 Resumen de Compilación'));
+    logger.info(chalk.gray(summaryLine)); // ⏱️ Tiempo total con formato elegante
+    if (totalTime) {
+        logger.info(chalk.bold(`⏱️  Tiempo Total: ${chalk.green(totalTime)}`));
+        logger.info('');
+    } // 🔧 Estadísticas por etapa con mejor formato
     if (compilationResults.length > 0) {
-        logger.info(chalk.blue('\n🔍 Estadísticas por etapa:'));
+        logger.info(chalk.bold.blue('🔧 Estadísticas por Etapa:'));
         for (const result of compilationResults) {
             const totalFiles = result.success + result.errors;
             const successRate = totalFiles > 0
                 ? Math.round((result.success / totalFiles) * 100)
                 : 0;
-            const statusIcon = result.errors === 0 ? '✅' : '❌';
-            const stageColor = await getStageColor(result.stage);
-            const statusText = `${result.success} éxitos, ${result.errors} errores`;
-            const coloredStatusText = result.errors === 0
-                ? chalk.green(statusText)
-                : chalk.red(statusText);
-            logger.info(`${statusIcon} ${stageColor(result.stage)}: ${coloredStatusText} (${successRate}% éxito)`);
+            // Iconos y colores dinámicos por etapa
+            const stageIcon = getStageIcon(result.stage);
+            const statusColor = result.errors === 0 ? chalk.green : chalk.red;
+            const progressBar = createProgressBarWithPercentage(successRate, 20);
+            logger.info(`   ${stageIcon} ${chalk.bold(result.stage)}`);
+            logger.info(`     ${statusColor('●')} ${result.success}/${totalFiles} archivos ${statusColor(`(${successRate}%)`)}`);
+            logger.info(`     ${progressBar}`);
+            if (result.errors > 0) {
+                logger.info(`     ${chalk.red('⚠')} ${result.errors} ${result.errors === 1 ? 'error' : 'errores'}`);
+            }
+            logger.info('');
         }
     }
     // Mostrar errores detallados
@@ -677,33 +1056,60 @@ async function displayCompilationSummary(isVerbose = false) {
                 }
             }
             fileIndex++;
-        }
-        // Mostrar totales finales
+        } // 📊 Mostrar totales finales con diseño moderno
         const totalErrors = compilationErrors.filter(e => e.severity === 'error').length;
         const totalWarnings = compilationErrors.filter(e => e.severity === 'warning').length;
         const totalFiles = errorsByFile.size;
-        logger.info(chalk.bold('\n--- 📈 ESTADÍSTICAS FINALES ---'));
-        logger.info(`📁 Archivos con errores: ${totalFiles}`);
-        logger.info(`❌ Total de errores: ${totalErrors}`);
-        logger.info(`⚠️ Total de advertencias: ${totalWarnings}`);
+        // Header elegante para estadísticas finales
+        const statLine = '═'.repeat(50);
+        logger.info('');
+        logger.info(chalk.bold.cyan(statLine));
+        logger.info(chalk.bold.cyan('                📊 RESUMEN FINAL'));
+        logger.info(chalk.bold.cyan(statLine));
+        // Estadísticas con iconos y colores modernos
+        logger.info('');
+        logger.info(chalk.bold('🎯 Resultados:'));
+        logger.info(`   📁 Archivos afectados: ${chalk.cyan.bold(totalFiles)}`);
+        logger.info(`   ${totalErrors > 0 ? chalk.red('●') : chalk.green('○')} Errores: ${totalErrors > 0 ? chalk.red.bold(totalErrors) : chalk.green.bold('0')}`);
+        logger.info(`   ${totalWarnings > 0 ? chalk.yellow('●') : chalk.green('○')} Advertencias: ${totalWarnings > 0 ? chalk.yellow.bold(totalWarnings) : chalk.green.bold('0')}`);
+        logger.info('');
+        // Estado final con diseño visual atractivo
         if (totalErrors > 0) {
-            logger.info(chalk.red('🚨 Compilación completada con errores que requieren atención.'));
+            logger.info(chalk.red.bold('🚨 COMPILACIÓN COMPLETADA CON ERRORES'));
+            logger.info(chalk.red('   Por favor revisa y corrige los problemas anteriores.'));
+        }
+        else if (totalWarnings > 0) {
+            logger.info(chalk.yellow.bold('⚠️  COMPILACIÓN COMPLETADA CON ADVERTENCIAS'));
+            logger.info(chalk.yellow('   Considera revisar las advertencias anteriores.'));
         }
         else {
-            logger.info(chalk.yellow('✅ Compilación completada con solo advertencias.'));
+            logger.info(chalk.green.bold('✅ COMPILACIÓN EXITOSA'));
+            logger.info(chalk.green('   ¡Todos los archivos se compilaron sin problemas!'));
         }
+        logger.info('');
+        logger.info(chalk.bold.cyan(statLine));
     }
     else {
-        logger.info(chalk.green('✅ ¡Compilación exitosa sin errores!'));
-    }
-    logger.info(chalk.bold('--- FIN DEL RESUMEN ---\n'));
+        // Caso exitoso sin errores
+        const successLine = '═'.repeat(50);
+        logger.info('');
+        logger.info(chalk.bold.green(successLine));
+        logger.info(chalk.bold.green('                ✨ ÉXITO'));
+        logger.info(chalk.bold.green(successLine));
+        logger.info('');
+        logger.info(chalk.green.bold('🎉 COMPILACIÓN COMPLETADA EXITOSAMENTE'));
+        logger.info(chalk.green('   ¡No se encontraron errores ni advertencias!'));
+        logger.info('');
+        logger.info(chalk.bold.green(successLine));
+    }
+    logger.info('');
 }
 /**
- * Muestra errores del linter de forma detallada
+ * Muestra errores del linter con formato visual moderno y profesional
  */
 async function displayLinterErrors(errors) {
     const chalk = await loadChalk();
-    logger.info(chalk.bold('--- Errores y Advertencias de Linting ---'));
+    // Agrupar errores por archivo
     const errorsByFile = new Map();
     errors.forEach(error => {
         if (!errorsByFile.has(error.file)) {
@@ -714,19 +1120,225 @@ async function displayLinterErrors(errors) {
     const totalErrors = errors.filter(e => e.severity === 'error').length;
     const totalWarnings = errors.filter(e => e.severity === 'warning').length;
     const totalFiles = errorsByFile.size;
-    logger.info(chalk.yellow(`📊 Resumen: ${totalErrors} errores, ${totalWarnings} advertencias en ${totalFiles} archivos\n`));
-    errorsByFile.forEach((fileErrors, filePath) => {
-        const baseName = path.basename(filePath);
-        logger.info(chalk.cyan(`\n📄 ${baseName}`));
-        fileErrors.forEach(error => {
-            const icon = error.severity === 'error' ? '❌' : '⚠️';
-            logger.info(`${icon} ${error.message}`);
-            if (error.help) {
-                logger.info(`   └─ ${error.help}`);
+    // Header estilo moderno con gradiente visual
+    logger.info(chalk.bold.rgb(255, 120, 120)('╭─────────────────────────────────────────────────────────────╮'));
+    logger.info(chalk.bold.rgb(255, 120, 120)('│                    ') +
+        chalk.bold.white('🔍 LINTER REPORT') +
+        chalk.bold.rgb(255, 120, 120)('                    │'));
+    logger.info(chalk.bold.rgb(255, 120, 120)('╰─────────────────────────────────────────────────────────────╯'));
+    // Resumen con iconos profesionales
+    const errorIcon = totalErrors > 0 ? chalk.red('●') : chalk.green('○');
+    const warningIcon = totalWarnings > 0 ? chalk.yellow('●') : chalk.green('○');
+    logger.info('');
+    logger.info(chalk.bold('📊 Summary:'));
+    logger.info(`   ${errorIcon} ${chalk.bold(totalErrors)} ${chalk.red('errors')}`);
+    logger.info(`   ${warningIcon} ${chalk.bold(totalWarnings)} ${chalk.yellow('warnings')}`);
+    logger.info(`   📁 ${chalk.bold(totalFiles)} ${chalk.cyan('files')}`);
+    logger.info('');
+    if (totalErrors === 0 && totalWarnings === 0) {
+        logger.info(chalk.green.bold('✨ All checks passed! No issues found.'));
+        return;
+    }
+    // Mostrar errores por archivo con formato elegante
+    let fileIndex = 1;
+    for (const [filePath, fileErrors] of errorsByFile) {
+        await displayFileErrorsGroup(filePath, fileErrors, fileIndex, totalFiles);
+        fileIndex++;
+        if (fileIndex <= totalFiles) {
+            logger.info(chalk.gray('─'.repeat(80))); // Separador entre archivos
+        }
+    }
+    // Footer con estadísticas
+    logger.info('');
+    logger.info(chalk.bold.rgb(255, 120, 120)('╭─────────────────────────────────────────────────────────────╮'));
+    logger.info(chalk.bold.rgb(255, 120, 120)('│  ') +
+        chalk.bold.white(`Found ${totalErrors + totalWarnings} issues in ${totalFiles} files`) +
+        ' '.repeat(Math.max(0, 52 -
+            `Found ${totalErrors + totalWarnings} issues in ${totalFiles} files`
+                .length)) +
+        chalk.bold.rgb(255, 120, 120)('  │'));
+    logger.info(chalk.bold.rgb(255, 120, 120)('╰─────────────────────────────────────────────────────────────╯'));
+}
+/**
+ * Muestra un grupo de errores para un archivo específico con formato moderno
+ */
+async function displayFileErrorsGroup(filePath, fileErrors, _fileIndex, _totalFiles) {
+    const chalk = await loadChalk();
+    // Header del archivo con iconos de estado
+    const errorCount = fileErrors.filter(e => e.severity === 'error').length;
+    const warningCount = fileErrors.filter(e => e.severity === 'warning').length;
+    const statusIcon = errorCount > 0 ? chalk.red('✕') : chalk.yellow('⚠');
+    const fileIcon = filePath.endsWith('.vue')
+        ? '🎨'
+        : filePath.endsWith('.ts')
+            ? '📘'
+            : filePath.endsWith('.js')
+                ? '📜'
+                : '📄';
+    logger.info('');
+    logger.info(chalk.bold(`${statusIcon} ${fileIcon} ${chalk.cyan(path.relative(process.cwd(), filePath))}`));
+    logger.info(chalk.gray(`   ${errorCount} errors, ${warningCount} warnings`));
+    logger.info('');
+    // Mostrar cada error con formato elegante
+    for (let i = 0; i < fileErrors.length; i++) {
+        const error = fileErrors[i];
+        await displayModernLinterError(error, filePath, i + 1, fileErrors.length);
+    }
+}
+/**
+ * Muestra un error individual con formato visual moderno tipo ESLint/Prettier
+ */
+async function displayModernLinterError(error, filePath, errorIndex, totalErrorsInFile) {
+    const chalk = await loadChalk();
+    const fs = await import('node:fs/promises');
+    // Determinar tipo y color del error
+    const isError = error.severity === 'error';
+    const typeColor = isError ? chalk.red : chalk.yellow;
+    const typeIcon = isError ? '✕' : '⚠';
+    const line = error.line || 1;
+    const column = error.column || 1;
+    const ruleId = error.ruleId || error.from || 'unknown';
+    // Línea principal del error con formato moderno
+    const errorHeader = `  ${typeColor(typeIcon)} ${chalk.bold(error.message)}`;
+    const ruleInfo = `${chalk.gray(ruleId)}`;
+    const locationInfo = `${chalk.blue(`${line}:${column}`)}`;
+    logger.info(errorHeader);
+    logger.info(`    ${chalk.gray('at')} ${locationInfo} ${chalk.gray('·')} ${ruleInfo}`);
+    // Mostrar código con contexto
+    try {
+        const absolutePath = path.resolve(filePath);
+        const fileContent = await fs.readFile(absolutePath, 'utf-8');
+        const lines = fileContent.split('\n');
+        const lineNum = parseInt(line.toString()) - 1;
+        if (lineNum >= 0 && lineNum < lines.length) {
+            logger.info('');
+            // Mostrar líneas de contexto con numeración elegante
+            const startLine = Math.max(0, lineNum - 1);
+            const endLine = Math.min(lines.length - 1, lineNum + 1);
+            const maxLineNumWidth = (endLine + 1).toString().length;
+            for (let i = startLine; i <= endLine; i++) {
+                const currentLineNum = i + 1;
+                const currentLine = lines[i] || '';
+                const lineNumStr = currentLineNum
+                    .toString()
+                    .padStart(maxLineNumWidth, ' ');
+                const isErrorLine = i === lineNum;
+                if (isErrorLine) {
+                    // Línea con el error - destacada
+                    logger.info(`    ${chalk.red('>')} ${chalk.gray(lineNumStr)} ${chalk.gray('│')} ${currentLine}`);
+                    // Indicador de posición del error
+                    const pointer = ' '.repeat(Math.max(0, column - 1)) + typeColor('^');
+                    logger.info(`    ${chalk.gray(' ')} ${chalk.gray(' '.repeat(maxLineNumWidth))} ${chalk.gray('│')} ${pointer}`);
+                }
+                else {
+                    // Líneas de contexto
+                    logger.info(`    ${chalk.gray(' ')} ${chalk.gray(lineNumStr)} ${chalk.gray('│')} ${chalk.gray(currentLine)}`);
+                }
             }
-        });
-    });
-    logger.info(chalk.bold('--- Fin de Errores y Advertencias ---\n'));
+        }
+    }
+    catch {
+        // Si no se puede leer el archivo, mostrar formato simplificado
+        logger.info(`    ${chalk.gray('│')} ${chalk.gray('(Unable to read file content)')}`);
+    }
+    // Mostrar ayuda si está disponible
+    if (error.help) {
+        logger.info('');
+        const helpText = error.help.replace(/^Regla \w+: /, '').trim();
+        logger.info(`    ${chalk.blue('💡')} ${chalk.blue('Help:')} ${chalk.gray(helpText)}`);
+    }
+    // Separador entre errores (solo si no es el último)
+    if (errorIndex < totalErrorsInFile) {
+        logger.info('');
+    }
+}
+/**
+ * Muestra un solo error del linter con formato visual mejorado
+ * @deprecated Use displayModernLinterError instead
+ */
+async function _displaySingleLinterError(error, filePath) {
+    const chalk = await loadChalk();
+    const fs = await import('node:fs/promises');
+    const icon = error.severity === 'error' ? '×' : '⚠';
+    const ruleInfo = error.help || '';
+    const line = error.line || 'N/A';
+    const column = error.column || 10; // Columna por defecto si no está disponible
+    // Línea principal del error
+    const mainErrorLine = `${chalk.red(icon)} ${chalk.cyan(`${error.from}(${ruleInfo.replace(/^Regla \w+: /, '')})`)}: ${error.message}`;
+    logger.info(mainErrorLine);
+    // Intentar leer el contenido del archivo para mostrar contexto
+    try {
+        const absolutePath = path.resolve(filePath);
+        const fileContent = await fs.readFile(absolutePath, 'utf-8');
+        const lines = fileContent.split('\n');
+        const lineNum = parseInt(line.toString()) - 1; // Convertir a índice 0-based
+        if (lineNum >= 0 && lineNum < lines.length) {
+            // Mostrar ubicación
+            logger.info(chalk.blue(`    ╭─[${filePath}:${line}:${column}]`));
+            // Mostrar líneas de contexto
+            const startLine = Math.max(0, lineNum - 1);
+            const endLine = Math.min(lines.length - 1, lineNum + 1);
+            for (let i = startLine; i <= endLine; i++) {
+                const currentLineNum = i + 1;
+                const currentLine = lines[i] || '';
+                const prefix = currentLineNum.toString().padStart(2, ' ');
+                if (i === lineNum) {
+                    // Línea con el error
+                    logger.info(chalk.blue(` ${prefix} │ `) + currentLine);
+                    // Mostrar el indicador de error
+                    const indent = ' '.repeat(prefix.length + 3); // Espacios para alinear
+                    const pointer = ' '.repeat(Math.max(0, (column || 1) - 1)) +
+                        chalk.red('───────┬──────');
+                    logger.info(chalk.blue(indent + '·') + pointer);
+                    // Mensaje de ubicación específica
+                    const messageIndent = ' '.repeat(Math.max(0, (column || 1) + 6));
+                    logger.info(chalk.blue(indent + '·') +
+                        messageIndent +
+                        chalk.red('╰── ') +
+                        chalk.gray(getErrorLocationMessage(error)));
+                }
+                else {
+                    // Líneas de contexto
+                    logger.info(chalk.blue(` ${prefix} │ `) + chalk.gray(currentLine));
+                }
+            }
+            logger.info(chalk.blue('    ╰────'));
+        }
+    }
+    catch {
+        // Si no se puede leer el archivo, mostrar formato simplificado
+        logger.info(chalk.blue(`    ╭─[${filePath}:${line}:${column}]`));
+        logger.info(chalk.blue('    │ ') +
+            chalk.gray('(No se pudo leer el contenido del archivo)'));
+        logger.info(chalk.blue('    ╰────'));
+    }
+    // Mostrar ayuda si está disponible
+    if (error.help) {
+        const helpMessage = error.help.replace(/^Regla \w+: /, '');
+        logger.info(chalk.blue('  help: ') + chalk.yellow(helpMessage));
+    }
+    logger.info(''); // Espacio entre errores
+}
+/**
+ * Genera un mensaje descriptivo para la ubicación específica del error
+ */
+function getErrorLocationMessage(error) {
+    if (error.message.includes('declared but never used')) {
+        const match = error.message.match(/'([^']+)'/);
+        if (match) {
+            return `'${match[1]}' is declared here`;
+        }
+    }
+    if (error.message.includes('Unexpected var')) {
+        return 'var declaration found here';
+    }
+    if (error.message.includes('never reassigned')) {
+        const match = error.message.match(/'([^']+)'/);
+        if (match) {
+            return `'${match[1]}' is assigned here`;
+        }
+    }
+    return 'error location';
 }
 /**
  * Obtiene el color apropiado para cada etapa de compilación
@@ -817,7 +1429,7 @@ class WatchModeOptimizer {
                         resolve({ success: true, cached: true });
                         return;
                     } // Configurar worker pool para modo watch
-                    const { TypeScriptWorkerPool } = await import('./typescript-worker-pool.js');
+                    const { TypeScriptWorkerPool } = (await import('./typescript-worker-pool.js'));
                     const workerPool = TypeScriptWorkerPool.getInstance();
                     workerPool.setMode('watch');
                     const result = await compileFn(filePath);
@@ -848,11 +1460,12 @@ async function compileJS(inPath, outPath, mode = 'individual') {
     const moduleManager = OptimizedModuleManager.getInstance();
     // Timing de lectura
     let start = Date.now();
-    const extension = path.extname(inPath);
-    // Asegurar que el parser esté cargado
+    const extension = path.extname(inPath); // Asegurar que el parser esté cargado
     await moduleManager.ensureModuleLoaded('parser');
     const getCodeFile = await loadParser();
-    let { code, error } = await getCodeFile(inPath);
+    const result = await getCodeFile(inPath);
+    let code = result.code;
+    const error = result.error;
     timings.fileRead = Date.now() - start;
     if (error) {
         await handleCompilationError(error instanceof Error ? error : new Error(String(error)), inPath, 'file-read', mode, env.VERBOSE === 'true');
@@ -864,15 +1477,13 @@ async function compileJS(inPath, outPath, mode = 'individual') {
         code === 'null') {
         await handleCompilationError(new Error('El archivo está vacío o no se pudo leer.'), inPath, 'file-read', mode, env.VERBOSE === 'true');
         throw new Error('El archivo está vacío o no se pudo leer.');
-    }
-    // Logs detallados solo en modo verbose + all
-    const shouldShowDetailedLogs = env.VERBOSE === 'true' && mode === 'all';
-    // Compilación de Vue
+    } // Logs detallados en modo verbose
+    const shouldShowDetailedLogs = env.VERBOSE === 'true'; // Compilación de Vue
     let vueResult;
     if (extension === '.vue') {
         start = Date.now();
         if (shouldShowDetailedLogs) {
-            logger.info(chalk.green(`💚 Precompilando VUE: ${inPath}`));
+            logger.info(chalk.green(`💚 Precompilando VUE: ${path.basename(inPath)}`));
         }
         // Asegurar que el módulo Vue esté cargado
         await moduleManager.ensureModuleLoaded('vue');
@@ -905,7 +1516,7 @@ async function compileJS(inPath, outPath, mode = 'individual') {
     if (extension === '.ts' || vueResult?.lang === 'ts') {
         start = Date.now();
         if (shouldShowDetailedLogs) {
-            logger.info(chalk.blue(`🔄️ Precompilando TS: ${inPath}`));
+            logger.info(chalk.blue(`🔄️ Precompilando TS: ${path.basename(inPath)}`));
         }
         // Asegurar que el módulo TypeScript esté cargado
         await moduleManager.ensureModuleLoaded('typescript');
@@ -940,10 +1551,9 @@ async function compileJS(inPath, outPath, mode = 'individual') {
     if (!code || code.trim().length === 0) {
         await handleCompilationError(new Error('El código TypeScript compilado está vacío.'), inPath, 'typescript', mode, env.VERBOSE === 'true');
         throw new Error('El código TypeScript compilado está vacío.');
-    }
-    // Estandarización
+    } // Estandarización
     if (shouldShowDetailedLogs) {
-        logger.info(chalk.yellow(`💛 Estandarizando: ${inPath}`));
+        logger.info(chalk.yellow(`💛 Estandarizando: ${path.basename(inPath)}`));
     }
     start = Date.now();
     // Asegurar que el módulo de transformaciones esté cargado
@@ -968,7 +1578,7 @@ async function compileJS(inPath, outPath, mode = 'individual') {
     if (env.isPROD === 'true') {
         start = Date.now();
         if (shouldShowDetailedLogs) {
-            logger.info(chalk.red(`🤖 Minificando: ${inPath}`));
+            logger.info(chalk.red(`🤖 Minificando: ${path.basename(inPath)}`));
         }
         // Asegurar que el módulo de minificación esté cargado
         await moduleManager.ensureModuleLoaded('minify');
@@ -988,11 +1598,26 @@ async function compileJS(inPath, outPath, mode = 'individual') {
         }
         registerCompilationSuccess(inPath, 'minification');
         code = resultMinify.code;
-    }
-    // Escribir archivo final
+    } // Escribir archivo final
     const destinationDir = path.dirname(outPath);
     await mkdir(destinationDir, { recursive: true });
     await writeFile(outPath, code, 'utf-8');
+    // Logs de timing detallados en modo verbose
+    if (shouldShowDetailedLogs) {
+        const totalTime = Object.values(timings).reduce((sum, time) => sum + time, 0);
+        logger.info(chalk.cyan(`⏱️ Timing para ${path.basename(inPath)}:`));
+        if (timings.fileRead)
+            logger.info(chalk.cyan(`  📖 Lectura: ${timings.fileRead}ms`));
+        if (timings.vueCompile)
+            logger.info(chalk.cyan(`  💚 Vue: ${timings.vueCompile}ms`));
+        if (timings.tsCompile)
+            logger.info(chalk.cyan(`  🔄️ TypeScript: ${timings.tsCompile}ms`));
+        if (timings.standardization)
+            logger.info(chalk.cyan(`  💛 Estandarización: ${timings.standardization}ms`));
+        if (timings.minification)
+            logger.info(chalk.cyan(`  🤖 Minificación: ${timings.minification}ms`));
+        logger.info(chalk.cyan(`  🏁 Total: ${totalTime}ms`));
+    }
     return {
         error: null,
         action: 'extension',
@@ -1025,6 +1650,20 @@ export async function initCompile(ruta, compileTailwind = true, mode = 'individu
         const startTime = Date.now();
         const file = normalizeRuta(ruta);
         const outFile = getOutputPath(file);
+        // 🚀 Verificar cache antes de compilar (especialmente importante en modo watch)
+        if (mode === 'watch' || mode === 'individual') {
+            if (await shouldSkipFile(file)) {
+                if (env.VERBOSE === 'true') {
+                    logger.info(`⏭️ Archivo omitido (cache): ${path.basename(file)}`);
+                }
+                return {
+                    success: true,
+                    cached: true,
+                    output: smartCache.getOutputPath(file) || outFile,
+                    action: 'cached',
+                };
+            }
+        }
         if (mode === 'individual' && env.VERBOSE === 'true') {
             logger.info(`🔜 Fuente: ${file}`);
         }
@@ -1032,6 +1671,10 @@ export async function initCompile(ruta, compileTailwind = true, mode = 'individu
         if (result.error) {
             throw new Error(result.error);
         }
+        // 🚀 Actualizar cache después de compilación exitosa (especialmente en modo watch)
+        if (mode === 'watch' || mode === 'individual') {
+            await smartCache.set(file, outFile);
+        }
         const endTime = Date.now();
         const elapsedTime = showTimingForHumans(endTime - startTime);
         if (mode === 'individual') {
@@ -1062,6 +1705,183 @@ export async function initCompile(ruta, compileTailwind = true, mode = 'individu
 }
 // Variable para el último progreso mostrado (evitar spam)
 let lastProgressUpdate = 0;
+// Sistema de gestión de progreso persistente (como Jest)
+class ProgressManager {
+    static instance;
+    progressActive = false;
+    lastProgressLine = '';
+    logBuffer = [];
+    originalConsoleLog;
+    originalConsoleError;
+    originalConsoleWarn;
+    hasProgressLine = false;
+    constructor() {
+        // Guardar referencias originales
+        this.originalConsoleLog = console.log;
+        this.originalConsoleError = console.error;
+        this.originalConsoleWarn = console.warn;
+    }
+    static getInstance() {
+        if (!ProgressManager.instance) {
+            ProgressManager.instance = new ProgressManager();
+        }
+        return ProgressManager.instance;
+    }
+    interceptConsole() {
+        // Interceptar console.log y similares
+        console.log = (...args) => {
+            this.addLog(args.map(arg => String(arg)).join(' '));
+        };
+        console.error = (...args) => {
+            this.addLog(args.map(arg => String(arg)).join(' '));
+        };
+        console.warn = (...args) => {
+            this.addLog(args.map(arg => String(arg)).join(' '));
+        };
+    }
+    restoreConsole() {
+        console.log = this.originalConsoleLog;
+        console.error = this.originalConsoleError;
+        console.warn = this.originalConsoleWarn;
+    }
+    startProgress() {
+        this.progressActive = true;
+        this.logBuffer = [];
+        this.hasProgressLine = false;
+        this.interceptConsole();
+        // 🎨 Header moderno de inicio de compilación
+        const headerLine = '━'.repeat(48);
+        process.stdout.write('\n\x1b[96m' + headerLine + '\x1b[0m\n');
+        process.stdout.write('\x1b[96m│ \x1b[97m\x1b[1m🚀 Iniciando Compilación\x1b[0m\x1b[96m' +
+            ' '.repeat(22) +
+            '│\x1b[0m\n');
+        process.stdout.write('\x1b[96m' + headerLine + '\x1b[0m\n');
+    }
+    updateProgress(progressText) {
+        if (!this.progressActive)
+            return;
+        // Si hay logs pendientes, mostrarlos primero
+        if (this.logBuffer.length > 0) {
+            // Si ya hay una línea de progreso, limpiarla primero
+            if (this.hasProgressLine) {
+                process.stdout.write('\r\x1b[K');
+            }
+            // Escribir todos los logs pendientes
+            for (const log of this.logBuffer) {
+                process.stdout.write((this.hasProgressLine ? '\n' : '') + log + '\n');
+                this.hasProgressLine = false;
+            }
+            this.logBuffer = [];
+        } // Escribir separador elegante antes del progreso
+        if (this.hasProgressLine) {
+            process.stdout.write('\r\x1b[K');
+        }
+        else {
+            process.stdout.write('\n\x1b[96m' + '▔'.repeat(50) + '\x1b[0m\n');
+        }
+        // 🎨 Barra de progreso con colores dinámicos
+        const stage = this.getStageFromText(progressText);
+        const { bgColor, textColor, icon } = this.getProgressColors(stage);
+        const progressBar = '█'.repeat(3);
+        const enhancedProgress = `\x1b[${bgColor}m\x1b[${textColor}m ${progressBar} ${icon} ${progressText} ${progressBar} \x1b[0m`;
+        process.stdout.write(enhancedProgress);
+        this.hasProgressLine = true;
+        this.lastProgressLine = progressText;
+    }
+    addLog(message) {
+        if (this.progressActive) {
+            this.logBuffer.push(message);
+        }
+        else {
+            this.originalConsoleLog(message);
+        }
+    }
+    addImmediateLog(message) {
+        if (this.progressActive) {
+            if (this.hasProgressLine) {
+                process.stdout.write('\r\x1b[K');
+            }
+            // Añadir un punto de separación visual para logs inmediatos
+            process.stdout.write('\x1b[90m│\x1b[0m ' + message + '\n');
+            this.hasProgressLine = false;
+        }
+        else {
+            this.originalConsoleLog(message);
+        }
+    }
+    endProgress() {
+        if (this.progressActive) {
+            if (this.hasProgressLine) {
+                process.stdout.write('\n');
+            }
+            // Mostrar barra de progreso final completa antes del separador
+            process.stdout.write('\n\x1b[33m' + '-'.repeat(50) + '\x1b[0m\n');
+            const finalProgressBar = '█'.repeat(3);
+            const finalProgress = `\x1b[42m\x1b[30m ${finalProgressBar} ✅ PROCESO COMPLETADO 100% ${finalProgressBar} \x1b[0m`;
+            process.stdout.write(finalProgress + '\n');
+            // 🎨 Footer moderno de finalización
+            const footerLine = '━'.repeat(48);
+            process.stdout.write('\x1b[92m' + footerLine + '\x1b[0m\n');
+            process.stdout.write('\x1b[92m│ \x1b[97m\x1b[1m✅ ¡Compilación Completada!\x1b[0m\x1b[92m' +
+                ' '.repeat(23) +
+                '│\x1b[0m\n');
+            process.stdout.write('\x1b[92m' + footerLine + '\x1b[0m\n\n');
+            // Escribir logs finales pendientes
+            if (this.logBuffer.length > 0) {
+                for (const log of this.logBuffer) {
+                    process.stdout.write(log + '\n');
+                }
+            }
+        }
+        this.restoreConsole();
+        this.progressActive = false;
+        this.lastProgressLine = '';
+        this.logBuffer = [];
+        this.hasProgressLine = false;
+    }
+    isActive() {
+        return this.progressActive;
+    }
+    /**
+     * 🎨 Determina la etapa del progreso basándose en el texto
+     */
+    getStageFromText(text) {
+        if (text.includes('Iniciando') || text.includes('Starting'))
+            return 'start';
+        if (text.includes('Tailwind') || text.includes('CSS'))
+            return 'tailwind';
+        if (text.includes('Recopilando') ||
+            text.includes('archivos') ||
+            text.includes('files'))
+            return 'files';
+        if (text.includes('Compilando') || text.includes('workers'))
+            return 'compile';
+        if (text.includes('cache') || text.includes('Guardando'))
+            return 'cache';
+        if (text.includes('linter') || text.includes('Linter'))
+            return 'linter';
+        if (text.includes('completado') || text.includes('Complete'))
+            return 'complete';
+        return 'default';
+    }
+    /**
+     * 🌈 Obtiene colores dinámicos para cada etapa
+     */
+    getProgressColors(stage) {
+        const colorSchemes = {
+            start: { bgColor: '45', textColor: '97', icon: '🚀' }, // Cyan brillante
+            tailwind: { bgColor: '105', textColor: '97', icon: '🎨' }, // Magenta
+            files: { bgColor: '43', textColor: '30', icon: '📁' }, // Amarillo
+            compile: { bgColor: '42', textColor: '30', icon: '⚙️' }, // Verde
+            cache: { bgColor: '44', textColor: '97', icon: '💾' }, // Azul
+            linter: { bgColor: '101', textColor: '97', icon: '🔍' }, // Rojo claro
+            complete: { bgColor: '102', textColor: '30', icon: '✅' }, // Verde claro
+            default: { bgColor: '100', textColor: '30', icon: '⏳' }, // Gris claro
+        };
+        const defaultColors = { bgColor: '100', textColor: '30', icon: '⏳' };
+        return colorSchemes[stage] || defaultColors;
+    }
+}
 // Función para ejecutar el linter antes de la compilación
 export async function runLinter(showResult = false) {
     const linterENV = env.linter;
@@ -1087,9 +1907,14 @@ export async function runLinter(showResult = false) {
                                 // Procesar resultados de ESLint
                                 if (Array.isArray(eslintResult.json)) {
                                     eslintResult.json.forEach((result) => {
+                                        const filePath = result.filePath ||
+                                            result.file ||
+                                            'archivo no especificado';
                                         linterErrors.push({
-                                            file: result.filePath ||
-                                                'archivo no especificado',
+                                            from: 'eslint',
+                                            line: result.line || 'N/A',
+                                            column: result.column || 1,
+                                            file: filePath,
                                             message: result.message,
                                             severity: result.severity === 2
                                                 ? 'error'
@@ -1106,9 +1931,16 @@ export async function runLinter(showResult = false) {
                                         if (fileResult.messages &&
                                             Array.isArray(fileResult.messages)) {
                                             fileResult.messages.forEach((msg) => {
+                                                const filePath = fileResult.filePath ||
+                                                    fileResult.file ||
+                                                    'archivo no especificado';
                                                 linterErrors.push({
-                                                    file: fileResult.filePath ||
-                                                        'archivo no especificado',
+                                                    from: 'eslint',
+                                                    line: msg.line ||
+                                                        'N/A',
+                                                    column: msg.column ||
+                                                        1,
+                                                    file: filePath,
                                                     message: msg.message,
                                                     severity: msg.severity ===
                                                         2
@@ -1140,20 +1972,40 @@ export async function runLinter(showResult = false) {
                             .then((oxlintResult) => {
                             if (oxlintResult &&
                                 oxlintResult['json'] &&
-                                Array.isArray(oxlintResult['json'])) {
-                                oxlintResult['json'].forEach((result) => {
+                                Array.isArray(oxlintResult['json']['diagnostics'])) {
+                                oxlintResult['json']['diagnostics'].forEach((result) => {
+                                    const filePath = result.filename ||
+                                        result.file ||
+                                        'archivo no especificado';
+                                    const lineNumber = result.labels &&
+                                        result.labels[0] &&
+                                        result.labels[0].span
+                                        ? result.labels[0].span
+                                            .line ||
+                                            result.labels[0].span
+                                                .start?.line
+                                        : 'N/A';
+                                    const columnNumber = result.labels &&
+                                        result.labels[0] &&
+                                        result.labels[0].span
+                                        ? result.labels[0].span
+                                            .column ||
+                                            result.labels[0].span
+                                                .start?.column
+                                        : 1;
                                     linterErrors.push({
-                                        file: result.filename ||
-                                            result.file ||
-                                            'archivo no especificado',
+                                        from: 'oxlint',
+                                        line: lineNumber,
+                                        column: columnNumber,
+                                        file: filePath,
                                         message: result.message,
                                         severity: typeof result.severity ===
                                             'string'
                                             ? result.severity.toLowerCase()
                                             : 'error',
                                         help: result.help ||
-                                            (result.rule_id
-                                                ? `Regla Oxlint: ${result.rule_id}`
+                                            (result.code
+                                                ? `Regla Oxlint: ${result.code}`
                                                 : undefined),
                                     });
                                 });
@@ -1176,6 +2028,7 @@ export async function runLinter(showResult = false) {
             }
             await Promise.all(linterPromises);
             if (showResult) {
+                // Modo --linter: Solo mostrar resultados sin preguntar
                 if (linterErrors.length > 0) {
                     await displayLinterErrors(linterErrors);
                 }
@@ -1184,21 +2037,24 @@ export async function runLinter(showResult = false) {
                     logger.info(chalk.green('✅ No se encontraron errores ni advertencias de linting.'));
                 }
             }
+            else {
+                // Modo compilación: Mostrar errores si los hay y preguntar al usuario
+                if (linterErrors.length > 0) {
+                    await displayLinterErrors(linterErrors);
+                    logger.warn('🚨 Se encontraron errores o advertencias durante el linting.');
+                    if (env.yes === 'false') {
+                        const result = await promptUser('¿Deseas continuar con la compilación a pesar de los errores de linting? (s/N): ');
+                        if (result.toLowerCase() !== 's') {
+                            logger.info('🛑 Compilación cancelada por el usuario.');
+                            proceedWithCompilation = false;
+                        }
+                    }
+                }
+            }
         }
         catch (parseError) {
             logger.warn(`Error parseando configuración de linter: ${parseError instanceof Error ? parseError.message : 'Error desconocido'}, omitiendo...`);
         }
-        if (!showResult && linterErrors.length > 0) {
-            await displayLinterErrors(linterErrors);
-            logger.warn('🚨 Se encontraron errores o advertencias durante el linting.');
-            if (env.yes === 'false') {
-                const result = await promptUser('¿Deseas continuar con la compilación a pesar de los errores de linting? (s/N): ');
-                if (result.toLowerCase() !== 's') {
-                    logger.info('🛑 Compilación cancelada por el usuario.');
-                    proceedWithCompilation = false;
-                }
-            }
-        }
     }
     return proceedWithCompilation;
 }
@@ -1220,23 +2076,47 @@ async function compileWithConcurrencyLimit(files, maxConcurrency = 8) {
     const total = files.length;
     let completed = 0;
     let skipped = 0;
-    let failed = 0; // Función para mostrar progreso
+    let failed = 0;
+    // Usar el gestor de progreso existente (ya iniciado en initCompileAll)
+    const progressManager = ProgressManager.getInstance();
+    // Variable para controlar el progreso inicial
+    let hasShownInitialProgress = false;
+    // Contador para limpieza periódica de memoria
+    let compilationCounter = 0;
+    const CLEANUP_INTERVAL = 20; // Limpiar cada 20 compilaciones
+    // Función para mostrar progreso
     function showProgress() {
         const currentTotal = completed + skipped + failed;
         const progressBar = createProgressBar(currentTotal, total);
         const progressPercent = Math.round((currentTotal / total) * 100);
-        if (progressPercent > lastProgressUpdate + 1 ||
+        // Mostrar progreso inicial cuando se inicie O cuando haya progreso real
+        if ((currentTotal === 0 && !hasShownInitialProgress) ||
+            (progressPercent > lastProgressUpdate + 1 && currentTotal > 0) ||
             currentTotal === total) {
-            stdout.write(`\r🚀 ${progressBar} [✅ ${completed} | ⏭️ ${skipped} | ❌ ${failed}]`);
+            const progressText = `🚀 ${progressBar} [✅ ${completed} | ⏭️ ${skipped} | ❌ ${failed}]`;
+            progressManager.updateProgress(progressText);
+            if (currentTotal === 0) {
+                hasShownInitialProgress = true;
+            }
             lastProgressUpdate = progressPercent;
+            // NO terminar el progreso aquí - se termina en initCompileAll
         }
     }
+    // Mostrar progreso inicial
+    showProgress();
     for (const file of files) {
         const promise = (async () => {
             try {
+                // Log verbose: Iniciando compilación del archivo
+                if (env.VERBOSE === 'true') {
+                    logger.info(`🔄 Compilando: ${path.basename(file)}`);
+                }
                 // Verificar cache antes de compilar
                 if (await shouldSkipFile(file)) {
                     skipped++;
+                    if (env.VERBOSE === 'true') {
+                        logger.info(`⏭️ Archivo omitido (cache): ${path.basename(file)}`);
+                    }
                     showProgress();
                     return {
                         success: true,
@@ -1244,16 +2124,54 @@ async function compileWithConcurrencyLimit(files, maxConcurrency = 8) {
                         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) {
                     await smartCache.set(file, result.output);
+                    if (env.VERBOSE === 'true') {
+                        logger.info(`✅ Completado: ${path.basename(file)} → ${path.basename(result.output)}`);
+                    }
+                }
+                else if (env.VERBOSE === 'true') {
+                    logger.info(`❌ Error en: ${path.basename(file)}`);
                 }
                 completed++;
+                compilationCounter++; // Limpieza periódica de memoria
+                if (compilationCounter % CLEANUP_INTERVAL === 0) {
+                    // Forzar garbage collection si está disponible
+                    try {
+                        if (typeof globalThis.gc === 'function') {
+                            globalThis.gc();
+                        }
+                    }
+                    catch {
+                        // gc no disponible, continuar normalmente
+                    }
+                    // Limpiar cache si la memoria es alta
+                    const memUsage = process.memoryUsage();
+                    const heapUsedMB = memUsage.heapUsed / (1024 * 1024);
+                    if (heapUsedMB > 300) {
+                        // Si el heap supera 300MB
+                        const cacheEntries = smartCache.getStats().entries;
+                        if (cacheEntries > 50) {
+                            console.log(`[Memory] Heap alto (${heapUsedMB.toFixed(1)}MB), limpiando cache...`);
+                            // Limpiar entradas más antiguas del cache
+                            const removedEntries = smartCache.cleanOldEntries(20);
+                            if (removedEntries > 0) {
+                                console.log(`[Memory] Se removieron ${removedEntries} entradas del cache`);
+                            }
+                        }
+                    }
+                }
                 showProgress();
                 return result;
             }
             catch (error) {
                 failed++;
+                if (env.VERBOSE === 'true') {
+                    const errorMsg = error instanceof Error ? error.message : String(error);
+                    logger.error(`💥 Falló: ${path.basename(file)} - ${errorMsg}`);
+                }
                 showProgress();
                 return {
                     success: false,
@@ -1269,18 +2187,26 @@ async function compileWithConcurrencyLimit(files, maxConcurrency = 8) {
         }
     }
     await Promise.all(results);
-    console.log('\n'); // Nueva línea después de la barra de progreso
+    // El progreso ya se termina automáticamente en showProgress() cuando se completa
 }
 export async function initCompileAll() {
     try {
+        // Inicializar el gestor de progreso desde el inicio
+        const progressManager = ProgressManager.getInstance();
+        progressManager.startProgress();
+        // Fase 1: Preparación inicial
+        progressManager.updateProgress('🚀 Iniciando compilación...');
         // Limpiar estado de compilación anterior
         clearCompilationState();
         // Cargar cache al inicio
+        progressManager.updateProgress('📦 Cargando cache...');
         await loadCache();
-        lastProgressUpdate = 0;
-        const shouldContinue = await runLinter();
+        lastProgressUpdate = 0; // Fase 2: Linting
+        progressManager.updateProgress('🔍 Ejecutando linter...');
+        const shouldContinue = await runLinter(false); // false = mostrar errores y preguntar si hay errores
         if (!shouldContinue) {
             // await displayCompilationSummary(env.VERBOSE === 'true');
+            progressManager.endProgress();
             return;
         }
         const startTime = Date.now();
@@ -1296,7 +2222,9 @@ export async function initCompileAll() {
         ];
         logger.info(`📝 Compilando todos los archivos...`);
         logger.info(`🔜 Fuente: ${rawPathSource}`);
-        logger.info(`🔚 Destino: ${pathDist}\n`); // Generar TailwindCSS
+        logger.info(`🔚 Destino: ${pathDist}\n`);
+        // Fase 3: TailwindCSS
+        progressManager.updateProgress('🎨 Generando TailwindCSS...');
         const generateTailwindCSS = await loadTailwind();
         const resultTW = await generateTailwindCSS();
         if (typeof resultTW !== 'boolean') {
@@ -1306,7 +2234,9 @@ export async function initCompileAll() {
             else {
                 await handleCompilationError(new Error(`${resultTW.message}${resultTW.details ? '\n' + resultTW.details : ''}`), 'tailwind.config.js', 'tailwind', 'all', env.VERBOSE === 'true');
             }
-        } // Recopilar todos los archivos
+        }
+        // Fase 4: Recopilando archivos
+        progressManager.updateProgress('📁 Recopilando archivos...');
         const filesToCompile = [];
         for await (const file of glob(patterns)) {
             if (file.endsWith('.d.ts')) {
@@ -1314,46 +2244,86 @@ export async function initCompileAll() {
             }
             // Usar la ruta tal como viene de glob, sin modificar
             filesToCompile.push(file);
-        }
-        // Determinar concurrencia óptima
+        } // Determinar concurrencia óptima considerando memoria disponible
         const cpuCount = os.cpus().length;
         const fileCount = filesToCompile.length;
+        const memUsage = process.memoryUsage();
+        const availableMemoryMB = (memUsage.heapTotal - memUsage.heapUsed) / (1024 * 1024);
         let maxConcurrency;
-        if (fileCount < 10) {
-            maxConcurrency = Math.min(fileCount, cpuCount);
+        // Ajustar concurrencia basado en memoria disponible y archivos
+        if (availableMemoryMB < 100) {
+            // Poca memoria disponible
+            maxConcurrency = Math.min(2, cpuCount);
+        }
+        else if (fileCount < 10) {
+            maxConcurrency = Math.min(fileCount, Math.min(cpuCount, 4));
         }
         else if (fileCount < 50) {
-            maxConcurrency = Math.min(cpuCount * 2, 12);
+            maxConcurrency = Math.min(cpuCount, 6); // Reducido
         }
         else {
-            maxConcurrency = Math.min(cpuCount * 2, 16);
+            maxConcurrency = Math.min(cpuCount, 8); // Reducido
         }
+        // Fase 5: Configurando workers
+        progressManager.updateProgress('⚙️ Configurando workers...');
         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 { 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
+        } // Fase 6: Compilación (el progreso continúa en compileWithConcurrencyLimit)
+        progressManager.updateProgress(`🚀 Iniciando compilación de ${fileCount} archivos...`);
+        await compileWithConcurrencyLimit(filesToCompile, maxConcurrency); // Guardar cache al final
+        progressManager.updateProgress('💾 Guardando cache...');
         await saveCache();
         const endTime = Date.now();
-        const elapsedTime = showTimingForHumans(endTime - startTime);
-        logger.info(`⏱️ Tiempo total de compilación: ${elapsedTime}\n`); // Mostrar resumen de compilación
-        await displayCompilationSummary(env.VERBOSE === 'true');
+        const elapsedTime = showTimingForHumans(endTime - startTime); // Finalizar progreso
+        progressManager.endProgress();
+        // Mostrar resumen de compilación con tiempo total
+        await displayCompilationSummary(env.VERBOSE === 'true', elapsedTime);
     }
     catch (error) {
+        // Asegurar que el progreso termine en caso de error
+        const progressManager = ProgressManager.getInstance();
+        if (progressManager.isActive()) {
+            progressManager.endProgress();
+        }
         const errorMessage = error instanceof Error ? error.message : String(error);
         logger.error(`🚩 Error al compilar todos los archivos: ${errorMessage}`);
         // Registrar el error en el sistema unificado
-        await handleCompilationError(error instanceof Error ? error : new Error(String(error)), 'compilación general', 'all', 'all', env.VERBOSE === 'true');
-        // Mostrar resumen incluso si hay errores generales
+        await handleCompilationError(error instanceof Error ? error : new Error(String(error)), 'compilación general', 'all', 'all', env.VERBOSE === 'true'); // Mostrar resumen incluso si hay errores generales
         await displayCompilationSummary(env.VERBOSE === 'true');
     }
 }
+/**
+ * 🎨 Obtiene icono apropiado para cada etapa
+ */
+function getStageIcon(stage) {
+    const icons = {
+        vue: '🎨',
+        typescript: '📘',
+        standardization: '💛',
+        minification: '🗜️',
+        tailwind: '🎨',
+        'file-read': '📖',
+        default: '⚙️',
+    };
+    return icons[stage] ?? '⚙️';
+}
+/**
+ *  Crea una barra de progreso visual con porcentaje
+ */
+function createProgressBarWithPercentage(percentage, width) {
+    const filled = Math.round((percentage / 100) * width);
+    const empty = width - filled;
+    // Usar código directo para evitar problemas de importación
+    const greenBar = '\x1b[32m' + '█'.repeat(filled) + '\x1b[0m';
+    const grayBar = '\x1b[90m' + '░'.repeat(empty) + '\x1b[0m';
+    return `${greenBar}${grayBar} ${percentage}%`;
+}
 // Función wrapper para compatibilidad con tests
 export async function compileFile(filePath) {
     return await initCompile(filePath, true, 'individual');