jerkjs 2.5.8 → 2.6.1

package/lib/core/server.js

@@ -18,6 +18,7 @@ const { globalStats } = require('../utils/globalStats');
 
 // Carga anticipada de módulos comunes para evitar cargas repetidas
 let hooksInstance = null;
+let errorHandlerInstance = null;
 const getHooks = () => {
   if (!hooksInstance) {
     hooksInstance = require('../../index.js').hooks;
@@ -25,6 +26,13 @@ const getHooks = () => {
   return hooksInstance;
 };
 
+const getErrorHandler = () => {
+  if (!errorHandlerInstance) {
+    errorHandlerInstance = require('../utils/errorHandler');
+  }
+  return errorHandlerInstance;
+};
+
 class APIServer {
   /**
    * Constructor del servidor
@@ -114,7 +122,8 @@ class APIServer {
     return async (req, res) => {
       try {
         // Disparar hook antes de procesar archivo estático
-        const hooks = getHooks();
+        // Usar la instancia de hooks del servidor para evitar llamadas repetidas a getHooks()
+        const hooks = this.hooks;
         if (hooks) {
           const hookResult = hooks.applyFilters('pre_static_file_serve', {
             req,
@@ -150,8 +159,8 @@ class APIServer {
           res.writeHead(403, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ error: 'Acceso denegado' }));
 
-          if (hooks) {
-            hooks.doAction('static_file_access_denied', req, res, normalizedPath);
+          if (this.hooks) {
+            this.hooks.doAction('static_file_access_denied', req, res, normalizedPath);
           }
           return;
         }
@@ -177,8 +186,8 @@ class APIServer {
                 try {
                   await fs.promises.access(indexPath);
                   // Disparar hook antes de servir archivo índice
-                  if (hooks) {
-                    hooks.doAction('serving_index_file', indexPath, req, res);
+                  if (this.hooks) {
+                    this.hooks.doAction('serving_index_file', indexPath, req, res);
                   }
 
                   const fileContent = await fs.promises.readFile(indexPath);
@@ -194,8 +203,8 @@ class APIServer {
                   res.end(fileContent);
 
                   // Disparar hook después de servir archivo
-                  if (hooks) {
-                    hooks.doAction('static_file_served', indexPath, req, res);
+                  if (this.hooks) {
+                    this.hooks.doAction('static_file_served', indexPath, req, res);
                   }
                   return;
                 } catch (e) {
@@ -207,8 +216,8 @@ class APIServer {
               res.writeHead(404, { 'Content-Type': 'application/json' });
               res.end(JSON.stringify({ error: 'Directorio no encontrado', path: dirPath }));
 
-              if (hooks) {
-                hooks.doAction('static_directory_no_index', dirPath, req, res);
+              if (this.hooks) {
+                this.hooks.doAction('static_directory_no_index', dirPath, req, res);
               }
               return;
             } else {
@@ -216,8 +225,8 @@ class APIServer {
               res.writeHead(404, { 'Content-Type': 'application/json' });
               res.end(JSON.stringify({ error: 'Archivo no encontrado', path: physicalPath }));
 
-              if (hooks) {
-                hooks.doAction('static_file_not_found', physicalPath, req, res);
+              if (this.hooks) {
+                this.hooks.doAction('static_file_not_found', physicalPath, req, res);
               }
               return;
             }
@@ -226,8 +235,8 @@ class APIServer {
             res.writeHead(404, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'Archivo no encontrado', path: physicalPath }));
 
-            if (hooks) {
-              hooks.doAction('static_file_not_found', physicalPath, req, res);
+            if (this.hooks) {
+              this.hooks.doAction('static_file_not_found', physicalPath, req, res);
             }
             return;
           }
@@ -242,8 +251,8 @@ class APIServer {
             try {
               await fs.promises.access(indexPath);
               // Disparar hook antes de servir archivo índice
-              if (hooks) {
-                hooks.doAction('serving_index_file', indexPath, req, res);
+              if (this.hooks) {
+                this.hooks.doAction('serving_index_file', indexPath, req, res);
               }
 
               const fileContent = await fs.promises.readFile(indexPath);
@@ -259,8 +268,8 @@ class APIServer {
               res.end(fileContent);
 
               // Disparar hook después de servir archivo
-              if (hooks) {
-                hooks.doAction('static_file_served', indexPath, req, res);
+              if (this.hooks) {
+                this.hooks.doAction('static_file_served', indexPath, req, res);
               }
               return;
             } catch (e) {
@@ -272,15 +281,15 @@ class APIServer {
           res.writeHead(404, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ error: 'Directorio no encontrado' }));
 
-          if (hooks) {
-            hooks.doAction('static_directory_no_index', dirPath, req, res);
+          if (this.hooks) {
+            this.hooks.doAction('static_directory_no_index', dirPath, req, res);
           }
           return;
         }
 
         // Disparar hook antes de leer archivo
-        if (hooks) {
-          hooks.doAction('before_reading_static_file', physicalPath, req, res);
+        if (this.hooks) {
+          this.hooks.doAction('before_reading_static_file', physicalPath, req, res);
         }
 
         // Leer y servir el archivo
@@ -300,34 +309,31 @@ class APIServer {
         res.end(fileContent);
 
         // Disparar hook después de servir archivo
-        if (hooks) {
-          hooks.doAction('static_file_served', physicalPath, req, res);
+        if (this.hooks) {
+          this.hooks.doAction('static_file_served', physicalPath, req, res);
         }
       } catch (error) {
         if (error.code === 'ENOENT') {
           res.writeHead(404, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ error: 'Archivo no encontrado', path: error.path }));
 
-          const hooks = getHooks();
-          if (hooks) {
-            hooks.doAction('static_file_not_found', error.path, req, res);
+          if (this.hooks) {
+            this.hooks.doAction('static_file_not_found', error.path, req, res);
           }
         } else if (error.code === 'EACCES') {
           res.writeHead(403, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({ error: 'Acceso denegado', path: error.path }));
 
-          const hooks = getHooks();
-          if (hooks) {
-            hooks.doAction('static_file_access_denied', error.path, req, res);
+          if (this.hooks) {
+            this.hooks.doAction('static_file_access_denied', error.path, req, res);
           }
         } else {
           // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
-          const { ErrorHandler } = require('../utils/errorHandler');
+          const { ErrorHandler } = getErrorHandler();
           ErrorHandler.handle(error, req, res, this.logger);
 
-          const hooks = getHooks();
-          if (hooks) {
-            hooks.doAction('static_file_error', error, req, res);
+          if (this.hooks) {
+            this.hooks.doAction('static_file_error', error, req, res);
           }
         }
       }
@@ -413,7 +419,6 @@ class APIServer {
 
     // Obtener el handler final según las configuraciones
     let finalHandler = routeConfig.handler;
-    const path = require('path');
 
     // Si se especifica un controlador, cargarlo y obtener el handler
     if (routeConfig.controller && routeConfig.handlerName) {
@@ -445,7 +450,6 @@ class APIServer {
       if (routeConfig.auth === 'session') {
         // Verificar si el servidor tiene sessionManager
         if (this.sessionManager) {
-          const { sessionAuth } = require('../middleware/session');
           const authMiddleware = sessionAuth(this.sessionManager, routeConfig.authOptions || {});
 
           // Crear un nuevo handler que ejecute la autenticación primero
@@ -473,7 +477,7 @@ class APIServer {
               }
             } catch (error) {
               // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
-              const { ErrorHandler } = require('../utils/errorHandler');
+              const { ErrorHandler } = getErrorHandler();
               if (!res.headersSent) {
                 ErrorHandler.handle(error, req, res, this.logger);
               }
@@ -530,7 +534,7 @@ class APIServer {
               }
             } catch (error) {
               // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
-              const { ErrorHandler } = require('../utils/errorHandler');
+              const { ErrorHandler } = getErrorHandler();
               if (!res.headersSent) {
                 ErrorHandler.handle(error, req, res, this.logger);
               }
@@ -603,9 +607,8 @@ class APIServer {
    */
   start() {
     // Disparar hook antes de iniciar el servidor
-    const hooks = getHooks();
-    if (hooks) {
-      hooks.doAction('pre_server_start', this);
+    if (this.hooks) {
+      this.hooks.doAction('pre_server_start', this);
     }
 
     if (this.https && Object.keys(this.httpsOptions).length > 0) {
@@ -645,11 +648,11 @@ class APIServer {
       this.logger.logMemoryUsage();
 
       // Disparar hook después de iniciar el servidor
-      if (hooks) {
-        hooks.doAction('post_server_start', this);
-        
+      if (this.hooks) {
+        this.hooks.doAction('post_server_start', this);
+
         // Disparar hook para inicializar extensiones después de que el servidor esté completamente iniciado
-        hooks.doAction('admin_extensions_initialize', this);
+        this.hooks.doAction('admin_extensions_initialize', this);
       }
     });
 
@@ -695,9 +698,8 @@ class APIServer {
     const { pathname, query } = parsedUrl;
 
     // Disparar hook antes de procesar la solicitud
-    const hooks = getHooks();
-    if (hooks) {
-      hooks.doAction('request_received', req, res);
+    if (this.hooks) {
+      this.hooks.doAction('request_received', req, res);
     }
 
     // Agregar propiedades útiles a la solicitud
@@ -758,16 +760,16 @@ class APIServer {
                 res.writeHead(200, { 'Content-Type': 'text/html' });
                 res.end(renderedHtml);
 
-                if (hooks) {
-                  hooks.doAction('view_rendered', viewName, data, req, res);
+                if (this.hooks) {
+                  this.hooks.doAction('view_rendered', viewName, data, req, res);
                 }
               } catch (error) {
                 // Usar el ErrorHandler para mostrar el stacktrace en color amarillo
                 const { ErrorHandler } = require('../utils/errorHandler');
                 ErrorHandler.handle(error, req, res, this.logger);
 
-                if (hooks) {
-                  hooks.doAction('view_render_error', viewName, data, req, res, error);
+                if (this.hooks) {
+                  this.hooks.doAction('view_render_error', viewName, data, req, res, error);
                 }
               }
             };
@@ -810,8 +812,8 @@ class APIServer {
               }
 
               if (res.finished) {
-                if (hooks) {
-                  hooks.doAction('middleware_response_finished', req, res);
+                if (this.hooks) {
+                  this.hooks.doAction('middleware_response_finished', req, res);
                 }
                 return; // Si el middleware respondió, salir
               }
@@ -825,8 +827,8 @@ class APIServer {
             // Agregar parámetros a la solicitud
             req.params = matchedRoute.params;
 
-            if (hooks) {
-              hooks.doAction('route_matched', matchedRoute, req, res);
+            if (this.hooks) {
+              this.hooks.doAction('route_matched', matchedRoute, req, res);
             }
 
             // Ejecutar handler de la ruta
@@ -840,8 +842,8 @@ class APIServer {
               res.writeHead(204);
               res.end();
 
-              if (hooks) {
-                hooks.doAction('options_response_sent', req, res);
+              if (this.hooks) {
+                this.hooks.doAction('options_response_sent', req, res);
               }
             }
           }
@@ -853,8 +855,8 @@ class APIServer {
             // Agregar parámetros a la solicitud
             req.params = matchedRoute.params;
 
-            if (hooks) {
-              hooks.doAction('route_matched', matchedRoute, req, res);
+            if (this.hooks) {
+              this.hooks.doAction('route_matched', matchedRoute, req, res);
             }
 
             // Ejecutar middlewares (excepto para rutas estáticas)
@@ -885,8 +887,8 @@ class APIServer {
                   }
 
                   if (res.finished) {
-                    if (hooks) {
-                      hooks.doAction('middleware_response_finished', req, res);
+                    if (this.hooks) {
+                      this.hooks.doAction('middleware_response_finished', req, res);
                     }
                     return; // Si el middleware respondió, salir
                   }
@@ -948,27 +950,28 @@ class APIServer {
             }
             globalStats.endpointHits.set(endpointKey, globalStats.endpointHits.get(endpointKey) + 1);
 
-            if (hooks) {
-              hooks.doAction('route_handler_executed', matchedRoute, req, res);
+            if (this.hooks) {
+              this.hooks.doAction('route_handler_executed', matchedRoute, req, res);
             }
           } else {
             // Ruta no encontrada
-            if (hooks) {
-              hooks.doAction('route_not_found', pathname, req, res);
+            if (this.hooks) {
+              this.hooks.doAction('route_not_found', pathname, req, res);
             }
             res.writeHead(404, { 'Content-Type': 'application/json' });
             res.end(JSON.stringify({ error: 'Ruta no encontrada', path: pathname }));
           }
         }
 
-        if (hooks) {
-          hooks.doAction('request_processed', req, res);
+        if (this.hooks) {
+          this.hooks.doAction('request_processed', req, res);
         }
       } catch (error) {
-        if (hooks) {
-          hooks.doAction('request_error', req, res, error);
+        if (this.hooks) {
+          this.hooks.doAction('request_error', req, res, error);
         }
 
+        const { ErrorHandler } = getErrorHandler();
         ErrorHandler.handle(error, req, res, this.logger);
       }
     });

package/lib/middleware/firewall.js

@@ -170,26 +170,31 @@ class Firewall {
     // Path traversal
     const pathTraversal = /\.\.\//g;
 
-    // Verificar patrones en URL
-    for (const pattern of sqlPatterns) {
-      if (pattern.test(path)) {
-        return {
-          matched: true,
-          rule: 'sql_injection',
-          action: 'block',
-          reason: 'Patrón de SQL Injection detectado'
-        };
+    // Verificar patrones en URL solo si hay parámetros (evitar falsos positivos)
+    if (path.includes('?')) {
+      for (const pattern of sqlPatterns) {
+        if (pattern.test(path)) {
+          return {
+            matched: true,
+            rule: 'sql_injection',
+            action: 'block',
+            reason: 'Patrón de SQL Injection detectado'
+          };
+        }
       }
     }
 
-    for (const pattern of xssPatterns) {
-      if (pattern.test(path)) {
-        return {
-          matched: true,
-          rule: 'xss_attack',
-          action: 'block',
-          reason: 'Patrón de XSS detectado'
-        };
+    // Verificar patrones XSS solo si hay parámetros (evitar falsos positivos)
+    if (path.includes('?')) {
+      for (const pattern of xssPatterns) {
+        if (pattern.test(path)) {
+          return {
+            matched: true,
+            rule: 'xss_attack',
+            action: 'block',
+            reason: 'Patrón de XSS detectado'
+          };
+        }
       }
     }
 
@@ -202,6 +207,34 @@ class Firewall {
       };
     }
 
+    // Verificar reglas personalizadas de headers X-
+    const { globalWAFStats } = require('../utils/globalWAFStats');
+    for (const [ruleId, rule] of globalWAFStats.xHeaderRules) {
+      const headerValue = headers[rule.headerName];
+      if (headerValue) {
+        // Verificar si coincide con el patrón de la regla
+        if (typeof rule.pattern === 'string') {
+          if (headerValue.includes(rule.pattern)) {
+            return {
+              matched: true,
+              rule: ruleId,
+              action: rule.action,
+              reason: rule.reason
+            };
+          }
+        } else if (rule.pattern instanceof RegExp) {
+          if (rule.pattern.test(headerValue)) {
+            return {
+              matched: true,
+              rule: ruleId,
+              action: rule.action,
+              reason: rule.reason
+            };
+          }
+        }
+      }
+    }
+
     // Verificar patrones en body si es string
     if (typeof body === 'string') {
       for (const pattern of sqlPatterns) {
@@ -374,16 +407,35 @@ class Firewall {
 
       const clientIP = this.getClientIP(req);
 
+      // Actualizar estadísticas globales de solicitudes procesadas
+      const { globalWAFStats } = require('../utils/globalWAFStats');
+      globalWAFStats.requestsProcessed++;
+
+      // Capturar el tamaño del cuerpo de la solicitud si existe
+      if (req.body) {
+        const bodySize = typeof req.body === 'string' ? Buffer.byteLength(req.body, 'utf8') :
+                         typeof req.body === 'object' ? Buffer.byteLength(JSON.stringify(req.body), 'utf8') : 0;
+        globalWAFStats.requestBytes += bodySize;
+        console.log(`[FIREWALL DEBUG] Bytes de solicitud actualizados: ${globalWAFStats.requestBytes}`);
+      } else {
+        console.log('[FIREWALL DEBUG] No hay cuerpo en la solicitud');
+      }
+
       // Verificar si la IP está bloqueada
       const blockInfo = this.isBlocked(clientIP);
       if (blockInfo.blocked) {
         this.logger.warn(`Solicitud bloqueada desde IP: ${clientIP}, razón: ${blockInfo.reason}`);
+        console.log(`[FIREWALL DEBUG] Solicitud bloqueada desde IP: ${clientIP}, razón: ${blockInfo.reason}`);
 
         // Disparar hook de evento de seguridad
         if (hooks) {
           hooks.doAction('firewall_ip_blocked', clientIP, blockInfo.reason, req, res);
         }
 
+        // Actualizar estadísticas de intentos de ataque
+        globalWAFStats.attackAttempts++;
+        console.log(`[FIREWALL DEBUG] Ataque detectado, attackAttempts ahora: ${globalWAFStats.attackAttempts}`);
+
         res.writeHead(403, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({
           error: 'Acceso denegado por firewall',
@@ -412,6 +464,14 @@ class Firewall {
             hooks.doAction('firewall_request_blocked', ruleMatch, clientIP, req, res);
           }
 
+          // Actualizar estadísticas de intentos de ataque
+          globalWAFStats.attackAttempts++;
+          console.log(`[FIREWALL DEBUG] Ataque bloqueado, attackAttempts ahora: ${globalWAFStats.attackAttempts}`);
+          
+          // Registrar el tipo de ataque
+          globalWAFStats.attackTypes.add(ruleMatch.rule);
+          console.log(`[FIREWALL DEBUG] Tipo de ataque registrado: ${ruleMatch.rule}`);
+
           res.writeHead(403, { 'Content-Type': 'application/json' });
           res.end(JSON.stringify({
             error: 'Solicitud bloqueada por firewall',
@@ -429,11 +489,46 @@ class Firewall {
         }
       }
 
+      // Registrar acceso a ruta en las estadísticas globales
+      const routeKey = `${req.method} ${req.url}`;
+      if (!globalWAFStats.routeAccesses.has(routeKey)) {
+        globalWAFStats.routeAccesses.set(routeKey, 0);
+      }
+      globalWAFStats.routeAccesses.set(routeKey, globalWAFStats.routeAccesses.get(routeKey) + 1);
+      console.log(`[FIREWALL DEBUG] Acceso a ruta registrado: ${routeKey}, total accesos: ${globalWAFStats.routeAccesses.get(routeKey)}`);
+
+      // Registrar hit al endpoint en las estadísticas globales
+      const endpointKey = `${req.method} ${req.url}`;
+      if (!globalWAFStats.endpointHits.has(endpointKey)) {
+        globalWAFStats.endpointHits.set(endpointKey, 0);
+      }
+      globalWAFStats.endpointHits.set(endpointKey, globalWAFStats.endpointHits.get(endpointKey) + 1);
+      console.log(`[FIREWALL DEBUG] Hit al endpoint registrado: ${endpointKey}, total hits: ${globalWAFStats.endpointHits.get(endpointKey)}`);
+
       // Disparar hook antes de continuar con el siguiente middleware
       if (hooks) {
         hooks.doAction('firewall_request_allowed', req, res);
       }
 
+      // Capturar el tamaño de la respuesta antes de enviarla
+      const originalEnd = res.end;
+      res.end = (chunk, encoding, callback) => {
+        console.log(`[FIREWALL DEBUG] Enviando respuesta, tamaño del chunk: ${chunk ? Buffer.byteLength(chunk, typeof encoding === 'string' ? encoding : 'utf8') : 0} bytes`);
+        
+        // Actualizar estadísticas globales de respuestas enviadas
+        globalWAFStats.responsesSent++;
+        console.log(`[FIREWALL DEBUG] responsesSent ahora: ${globalWAFStats.responsesSent}`);
+        
+        // Capturar el tamaño del cuerpo de la respuesta si existe
+        if (chunk) {
+          const responseSize = Buffer.byteLength(chunk, typeof encoding === 'string' ? encoding : 'utf8');
+          globalWAFStats.responseBytes += responseSize;
+          console.log(`[FIREWALL DEBUG] responseBytes ahora: ${globalWAFStats.responseBytes}`);
+        }
+
+        return originalEnd.call(res, chunk, encoding, callback);
+      };
+
       // Continuar con el siguiente middleware
       next();
     };

package/lib/mvc/viewEngine.js

@@ -7,24 +7,29 @@
 
 const fs = require('fs');
 const path = require('path');
+const { globalViewCacheInfo } = require('../utils/globalViewCacheInfo');
 
 class ViewEngine {
   constructor(options = {}) {
     this.viewsPath = options.viewsPath || './views';
     this.defaultExtension = options.defaultExtension || '.html';
     this.cacheEnabled = options.cacheEnabled !== false; // Por defecto habilitado
-    this.viewCache = new Map(); // Cache de vistas compiladas
     this.logger = options.logger || console;
-    
+
+    // Usar el mapa global para el caché de vistas
+    this.viewCache = globalViewCacheInfo.viewCache;
+    this.cacheStats = globalViewCacheInfo.cacheStats;
+    this.viewDependencies = globalViewCacheInfo.viewDependencies;
+
     // Sistema de hooks para extensibilidad
     this.hooks = options.hooks || null;
-    
+
     // Sistema de filtros
     this.filters = new Map();
     this.helpers = new Map(); // Sistema de helpers personalizados
     this.registerDefaultFilters();
     this.registerDefaultHelpers();
-    
+
     // Asegurar que el directorio de vistas existe
     if (!fs.existsSync(this.viewsPath)) {
       fs.mkdirSync(this.viewsPath, { recursive: true });
@@ -224,6 +229,7 @@ class ViewEngine {
     // Intentar obtener del cache si está habilitado
     if (this.cacheEnabled && this.viewCache.has(viewPath)) {
       const cachedView = this.viewCache.get(viewPath);
+      this.cacheStats.hits++; // Incrementar contador de hits
       return this.processTemplate(cachedView, data, options);
     }
 
@@ -275,21 +281,30 @@ class ViewEngine {
     // Si el cache está habilitado, guardar la vista compilada (sin variables)
     if (this.cacheEnabled) {
       // Aplicar filter antes de cachear la vista
-      const contentToCache = this.hooks ? 
+      const contentToCache = this.hooks ?
         this.hooks.applyFilters('before_view_cache', viewContent, viewPath) : viewContent;
-      
+
       // Verificar con hook si se debe cachear esta vista
-      const shouldCache = this.hooks ? 
+      const shouldCache = this.hooks ?
         this.hooks.applyFilters('should_cache_view', true, viewPath, contentToCache) : true;
-      
+
       if (shouldCache) {
         this.viewCache.set(viewPath, contentToCache);
-        
+        this.cacheStats.misses++; // Incrementar contador de misses (ya que se leyó del disco)
+        this.cacheStats.totalViews++; // Incrementar total de vistas únicas
+
+        // Registrar dependencias de inclusiones
+        this.trackViewDependencies(viewPath, contentToCache);
+
         // Disparar hook después de cachear
         if (this.hooks) {
           this.hooks.doAction('view_cached', viewPath, contentToCache);
         }
+      } else {
+        this.cacheStats.misses++; // Aún se leyó del disco aunque no se cacheó
       }
+    } else {
+      this.cacheStats.misses++; // Se leyó del disco sin cache
     }
 
     // Procesar el template con las variables
@@ -775,6 +790,42 @@ class ViewEngine {
     return value;
   }
 
+  /**
+   * Registra las dependencias de inclusiones de una vista
+   * @param {string} viewPath - Ruta de la vista principal
+   * @param {string} content - Contenido de la vista
+   */
+  trackViewDependencies(viewPath, content) {
+    // Patrón para encontrar bloques de inclusión como {{include:nombre_vista}}
+    const includePattern = /\{\{include:(.*?)\}\}/g;
+    let match;
+    
+    while ((match = includePattern.exec(content)) !== null) {
+      const includePath = match[1].trim();
+      
+      // Obtener la ruta completa de la vista incluida
+      let includedViewPath;
+      if (includePath.startsWith('./') || includePath.startsWith('../')) {
+        includedViewPath = path.resolve(path.dirname(viewPath), includePath);
+        if (!path.extname(includedViewPath)) {
+          includedViewPath += this.defaultExtension;
+        }
+      } else {
+        // Usar la ruta de vistas por defecto
+        includedViewPath = path.join(this.viewsPath, includePath.replace(/\./g, '/'));
+        if (!path.extname(includedViewPath)) {
+          includedViewPath += this.defaultExtension;
+        }
+      }
+
+      // Registrar la dependencia
+      if (!this.viewDependencies.has(viewPath)) {
+        this.viewDependencies.set(viewPath, new Set());
+      }
+      this.viewDependencies.get(viewPath).add(includedViewPath);
+    }
+  }
+
   /**
    * Parsea argumentos de filtros o helpers, respetando cadenas entre comillas
    * @param {string} argsString - Cadena de argumentos
@@ -836,9 +887,17 @@ class ViewEngine {
     if (this.hooks) {
       this.hooks.doAction('before_view_cache_clear', this);
     }
-    
+
+    // Limpiar solo las vistas asociadas a esta instancia (si se desea)
+    // Para el sistema global, limpiar completamente
     this.viewCache.clear();
+    this.viewDependencies.clear();
     
+    // Reiniciar estadísticas
+    this.cacheStats.hits = 0;
+    this.cacheStats.misses = 0;
+    this.cacheStats.totalViews = 0;
+
     // Disparar hook después de limpiar el caché
     if (this.hooks) {
       this.hooks.doAction('view_cache_cleared');