gbu-accessibility-package 3.11.0 → 3.12.1

package/lib/fixer.js

@@ -5833,6 +5833,163 @@ class AccessibilityFixer {
     return files;
   }
 
+  // Check meta tags in HTML files
+  async checkMetaTags(directory = '.') {
+    console.log(chalk.blue('🔍 Checking meta tags for typos and syntax errors...'));
+    
+    const htmlFiles = await this.findHtmlFiles(directory);
+    let totalFiles = 0;
+    let filesWithErrors = 0;
+    let skippedFiles = 0;
+    let totalErrors = 0;
+    
+    for (const file of htmlFiles) {
+      try {
+        const content = await fs.readFile(file, 'utf8');
+        const analysis = this.analyzeMetaTags(content, file);
+        const relativePath = path.relative(directory, file);
+        
+        if (analysis.isIncludeFile) {
+          skippedFiles++;
+          console.log(chalk.gray(`⏭️  Skipped: ${relativePath} (include file)`));
+          continue;
+        }
+        
+        totalFiles++;
+        
+        if (analysis.errors.length > 0) {
+          filesWithErrors++;
+          totalErrors += analysis.errors.length;
+          console.log(chalk.red(`\n❌ ${relativePath}`));
+          analysis.errors.forEach((error, index) => {
+            console.log(chalk.red(`   ${index + 1}. ${error}`));
+          });
+        } else {
+          console.log(chalk.green(`✅ ${relativePath} - No errors`));
+        }
+      } catch (error) {
+        console.log(chalk.red(`❌ Error reading ${file}: ${error.message}`));
+      }
+    }
+    
+    console.log(chalk.blue('\n📊 Summary:'));
+    console.log(`   Total files checked: ${totalFiles}`);
+    console.log(`   Files skipped (includes): ${skippedFiles}`);
+    console.log(chalk.red(`   Files with errors: ${filesWithErrors}`));
+    console.log(chalk.red(`   Total errors found: ${totalErrors}`));
+    console.log(chalk.green(`   Files OK: ${totalFiles - filesWithErrors}`));
+    
+    if (filesWithErrors > 0) {
+      console.log(chalk.yellow(`\n💡 Sử dụng --meta-fix để tự động sửa các lỗi này`));
+    }
+  }
+
+  // Fix meta tags in HTML files
+  async fixMetaTags(directory = '.', options = {}) {
+    const { dryRun = false, backup = false } = options;
+    console.log(chalk.blue('🔧 Fixing meta tag typos and syntax errors...'));
+    
+    const htmlFiles = await this.findHtmlFiles(directory);
+    let totalFiles = 0;
+    let fixedFiles = 0;
+    let skippedFiles = 0;
+    let totalFixes = 0;
+    
+    for (const file of htmlFiles) {
+      try {
+        const content = await fs.readFile(file, 'utf8');
+        const analysis = this.analyzeMetaTags(content, file);
+        const relativePath = path.relative(directory, file);
+        
+        if (analysis.isIncludeFile) {
+          skippedFiles++;
+          console.log(chalk.gray(`⏭️  Skipped: ${relativePath} (include file)`));
+          continue;
+        }
+        
+        totalFiles++;
+        
+        if (analysis.fixable.length === 0) {
+          console.log(chalk.green(`✅ ${relativePath} - No errors to fix`));
+          continue;
+        }
+        
+        console.log(chalk.yellow(`\n🔧 Fixing: ${relativePath}`));
+        
+        let newContent = content;
+        let fixCount = 0;
+        
+        // Group fixes by tag to handle multiple fixes on same tag
+        const tagFixes = new Map();
+        for (const fix of analysis.fixable) {
+          if (!tagFixes.has(fix.fullTag)) {
+            tagFixes.set(fix.fullTag, []);
+          }
+          tagFixes.get(fix.fullTag).push(fix);
+        }
+        
+        // Apply all fixes for each tag
+        for (const [originalTag, fixes] of tagFixes) {
+          let newTag = originalTag;
+          
+          for (const fix of fixes) {
+            if (fix.type === 'property') {
+              // Fix property name typo
+              newTag = newTag.replace(
+                new RegExp(`((?:name|property)\\s*=\\s*["'])${fix.wrong.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(["'])`, 'i'),
+                `$1${fix.correct}$2`
+              );
+              console.log(chalk.green(`   ✓ Fixed property: ${fix.wrong} → ${fix.correct}`));
+              fixCount++;
+            } else if (fix.type === 'content') {
+              // Fix content value typo
+              newTag = newTag.replace(
+                new RegExp(`(content\\s*=\\s*["'])${fix.wrong.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(["'])`, 'i'),
+                `$1${fix.correct}$2`
+              );
+              console.log(chalk.green(`   ✓ Fixed ${fix.property} value: ${fix.wrong} → ${fix.correct}`));
+              fixCount++;
+            }
+          }
+          
+          // Replace the original tag with the fixed tag
+          newContent = newContent.replace(originalTag, newTag);
+        }
+        
+        // Save file if modified
+        if (fixCount > 0) {
+          if (!dryRun) {
+            // Create backup if enabled
+            if (backup) {
+              const backupPath = `${file}.bak`;
+              await fs.writeFile(backupPath, content, 'utf8');
+            }
+            
+            await fs.writeFile(file, newContent, 'utf8');
+            console.log(chalk.green(`   💾 Saved ${fixCount} fix(es) to ${relativePath}`));
+            fixedFiles++;
+            totalFixes += fixCount;
+          } else {
+            console.log(chalk.blue(`   🔍 Dry run - would fix ${fixCount} error(s) in ${relativePath}`));
+            totalFixes += fixCount;
+          }
+        }
+      } catch (error) {
+        console.log(chalk.red(`❌ Error processing ${file}: ${error.message}`));
+      }
+    }
+    
+    console.log(chalk.blue('\n📊 Summary:'));
+    console.log(`   Total files checked: ${totalFiles}`);
+    console.log(`   Files skipped (includes): ${skippedFiles}`);
+    console.log(chalk.green(`   Files fixed: ${fixedFiles}`));
+    console.log(chalk.green(`   Total fixes applied: ${totalFixes}`));
+    
+    if (dryRun) {
+      console.log(chalk.blue('\n💡 This was a dry run. Use without --dry-run to apply changes.'));
+    }
+  }
+
   // Check for unused files in the project - enhanced for comprehensive project-wide scanning
   async checkUnusedFiles(directory = '.') {
     console.log(chalk.blue('🗂️ Analyzing unused files across entire project...'));
@@ -5916,6 +6073,134 @@ class AccessibilityFixer {
     };
   }
 
+  resolveUnusedFilesListPath(directory = '.', listFile = 'unused-files-list.txt') {
+    const scanDirectory = path.resolve(directory);
+    const listFileName = listFile || 'unused-files-list.txt';
+
+    if (path.isAbsolute(listFileName)) {
+      return listFileName;
+    }
+
+    return path.join(scanDirectory, listFileName);
+  }
+
+  async generateUnusedFilesList(directory = '.', listFile = 'unused-files-list.txt') {
+    const scanDirectory = path.resolve(directory);
+    const outputPath = this.resolveUnusedFilesListPath(scanDirectory, listFile);
+    const unusedResults = await this.checkUnusedFiles(scanDirectory);
+    const fileContent = unusedResults.unusedFiles
+      .map(file => file.relativePath.replace(/\\/g, '/'))
+      .join('\n');
+
+    await fs.writeFile(outputPath, fileContent ? `${fileContent}\n` : '', 'utf8');
+
+    console.log(chalk.green(`📝 Đã tạo danh sách file dư thừa tại: ${outputPath}`));
+    console.log(chalk.gray(`📊 Ghi ${unusedResults.unusedCount} path vào file list`));
+
+    return {
+      ...unusedResults,
+      outputPath
+    };
+  }
+
+  async deleteUnusedFilesFromList(directory = '.', listFile = 'unused-files-list.txt', options = {}) {
+    const scanDirectory = path.resolve(directory);
+    const listPath = this.resolveUnusedFilesListPath(scanDirectory, listFile);
+    const dryRun = Boolean(options.dryRun);
+    const deletedFiles = [];
+    const missingFiles = [];
+    const skippedEntries = [];
+
+    const content = await fs.readFile(listPath, 'utf8');
+    const entries = [...new Set(
+      content
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(line => line && !line.startsWith('#'))
+    )];
+
+    for (const entry of entries) {
+      const normalizedEntry = entry.replace(/\\/g, '/');
+      const resolvedPath = path.resolve(scanDirectory, normalizedEntry);
+      const relativeToScan = path.relative(scanDirectory, resolvedPath);
+
+      if (relativeToScan.startsWith('..') || path.isAbsolute(relativeToScan)) {
+        skippedEntries.push({
+          path: entry,
+          reason: 'Path nằm ngoài thư mục target'
+        });
+        continue;
+      }
+
+      if (resolvedPath === path.resolve(listPath)) {
+        skippedEntries.push({
+          path: entry,
+          reason: 'Bỏ qua chính file list'
+        });
+        continue;
+      }
+
+      try {
+        const stats = await fs.lstat(resolvedPath);
+
+        if (!stats.isFile() && !stats.isSymbolicLink()) {
+          skippedEntries.push({
+            path: entry,
+            reason: 'Không phải file'
+          });
+          continue;
+        }
+
+        if (!dryRun) {
+          await fs.unlink(resolvedPath);
+        }
+
+        deletedFiles.push({
+          path: resolvedPath,
+          relativePath: relativeToScan.replace(/\\/g, '/')
+        });
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          missingFiles.push({
+            path: entry,
+            reason: 'File không tồn tại'
+          });
+          continue;
+        }
+
+        skippedEntries.push({
+          path: entry,
+          reason: error.message
+        });
+      }
+    }
+
+    console.log(chalk.green(
+      dryRun
+        ? `🧪 Dry run: ${deletedFiles.length} file trong list sẽ được xóa`
+        : `🗑️ Đã xóa ${deletedFiles.length} file từ list`
+    ));
+
+    if (missingFiles.length > 0) {
+      console.log(chalk.yellow(`⚠️ ${missingFiles.length} path không còn tồn tại`));
+    }
+
+    if (skippedEntries.length > 0) {
+      console.log(chalk.yellow(`⚠️ ${skippedEntries.length} path bị bỏ qua để đảm bảo an toàn hoặc không hợp lệ`));
+    }
+
+    return {
+      listPath,
+      deletedFiles,
+      deletedCount: deletedFiles.length,
+      missingFiles,
+      missingCount: missingFiles.length,
+      skippedEntries,
+      skippedCount: skippedEntries.length,
+      dryRun
+    };
+  }
+
   // Enhanced file reference checking - now works with relative paths
   isFileReferenced(filePath, relativePath, referencedFiles, projectRoot) {
     // Check various possible reference formats
@@ -6124,12 +6409,14 @@ class AccessibilityFixer {
       /<a[^>]*href\s*=\s*["']([^"'#]+\.html?)["']/gi,
       // Video/Audio
       /<(?:video|audio)[^>]*src\s*=\s*["']([^"']+)["']/gi,
+      // Video poster
+      /<video[^>]*poster\s*=\s*["']([^"']+)["']/gi,
       // Object/Embed
       /<(?:object|embed)[^>]*src\s*=\s*["']([^"']+)["']/gi,
       // Iframe
       /<iframe[^>]*src\s*=\s*["']([^"']+)["']/gi,
-      // Meta (for icons)
-      /<meta[^>]*content\s*=\s*["']([^"']+\.(ico|png|jpg|jpeg|svg))["']/gi,
+      // Meta tags (for OG images, icons) - including absolute URLs
+      /<meta[^>]*content\s*=\s*["']([^"']+)["']/gi,
       // Server Side Includes (SSI)
       /<!--#include\s+virtual\s*=\s*["']([^"']+)["']\s*-->/gi,
       /<!--#include\s+file\s*=\s*["']([^"']+)["']\s*-->/gi
@@ -6140,17 +6427,49 @@ class AccessibilityFixer {
       while ((match = pattern.exec(content)) !== null) {
         const url = match[1];
         
-        // Handle srcset format: "image1.jpg 1x, image2.jpg 2x"
+        // Handle srcset format: "image1.jpg 1x, image2.jpg 2x" or "image1.jpg 480w, image2.jpg 800w"
         if (pattern.source.includes('srcset')) {
-          const srcsetUrls = url.split(',').map(item => item.trim().split(' ')[0]);
-          srcsetUrls.forEach(srcUrl => {
-            if (this.isLocalFile(srcUrl)) {
-              this.addNormalizedUrl(references, srcUrl);
+          // Split by comma to get individual srcset entries
+          const srcsetEntries = url.split(',');
+          srcsetEntries.forEach(entry => {
+            // Each entry format: "url descriptor" where descriptor is 1x, 2x, 480w, etc.
+            // Split by whitespace and take the first part (the URL)
+            const parts = entry.trim().split(/\s+/);
+            const srcUrl = parts[0];
+            
+            if (srcUrl) {
+              const normalizedSrcUrl = this.normalizeReferenceUrl(srcUrl);
+              if (!normalizedSrcUrl) {
+                return;
+              }
+
+              // Check if it's a local file
+              if (this.isLocalFile(normalizedSrcUrl)) {
+                this.addNormalizedUrl(references, normalizedSrcUrl);
+              } else if (this.isAbsoluteUrlToLocalFile(normalizedSrcUrl)) {
+                // Extract local path from absolute URL (e.g., https://example.com/assets/img/file.png -> /assets/img/file.png)
+                const localPath = this.extractLocalPathFromAbsoluteUrl(normalizedSrcUrl);
+                if (localPath) {
+                  this.addNormalizedUrl(references, localPath);
+                }
+              }
             }
           });
         } else {
-          if (this.isLocalFile(url)) {
-            this.addNormalizedUrl(references, url);
+          const normalizedUrl = this.normalizeReferenceUrl(url);
+          if (!normalizedUrl) {
+            continue;
+          }
+
+          // Regular src/href/content attributes
+          if (this.isLocalFile(normalizedUrl)) {
+            this.addNormalizedUrl(references, normalizedUrl);
+          } else if (this.isAbsoluteUrlToLocalFile(normalizedUrl)) {
+            // Extract local path from absolute URL
+            const localPath = this.extractLocalPathFromAbsoluteUrl(normalizedUrl);
+            if (localPath) {
+              this.addNormalizedUrl(references, localPath);
+            }
           }
         }
       }
@@ -6159,15 +6478,77 @@ class AccessibilityFixer {
     return references;
   }
 
+  // Check if URL is an absolute URL that points to a local file (same domain or project assets)
+  isAbsoluteUrlToLocalFile(url) {
+    const normalizedUrl = this.normalizeReferenceUrl(url);
+    if (!normalizedUrl) {
+      return false;
+    }
+
+    if (!normalizedUrl.startsWith('http://') && !normalizedUrl.startsWith('https://')) {
+      return false;
+    }
+    
+    // Check if URL contains common asset paths (customize based on your project structure)
+    // This helps identify URLs like: https://www.example.com/assets/img/file.png
+    return normalizedUrl.includes('/assets/') || 
+           normalizedUrl.includes('/static/') || 
+           normalizedUrl.includes('/img/') ||
+           normalizedUrl.includes('/images/') ||
+           normalizedUrl.includes('/css/') ||
+           normalizedUrl.includes('/js/') ||
+           normalizedUrl.includes('/media/') ||
+           normalizedUrl.includes('/fonts/') ||
+           normalizedUrl.match(/\.(jpg|jpeg|png|gif|svg|webp|css|js|ico|pdf|mp4|webm)$/i);
+  }
+
+  // Extract local path from absolute URL
+  // e.g., "https://www.example.com/assets/img/file.png" -> "/assets/img/file.png"
+  extractLocalPathFromAbsoluteUrl(url) {
+    try {
+      const normalizedUrl = this.normalizeReferenceUrl(url);
+      if (!normalizedUrl) {
+        return null;
+      }
+
+      const urlObj = new URL(normalizedUrl);
+      return urlObj.pathname; // Returns "/assets/img/file.png"
+    } catch (error) {
+      return null;
+    }
+  }
+
+  normalizeReferenceUrl(url) {
+    if (typeof url !== 'string') {
+      return null;
+    }
+
+    const trimmedUrl = url.trim();
+    if (!trimmedUrl) {
+      return null;
+    }
+
+    const withoutHash = trimmedUrl.split('#')[0];
+    const withoutQuery = withoutHash.split('?')[0];
+    const normalizedUrl = withoutQuery.trim().replace(/\\/g, '/');
+
+    return normalizedUrl || null;
+  }
+
   // Helper method to add normalized URL variations
   addNormalizedUrl(references, url) {
+    const normalizedUrl = this.normalizeReferenceUrl(url);
+    if (!normalizedUrl) {
+      return;
+    }
+
     // Store original URL and normalized versions for matching
-    references.push(url);
-    if (url.startsWith('/')) {
-      references.push(url.substring(1)); // Remove leading slash
+    references.push(normalizedUrl);
+    if (normalizedUrl.startsWith('/')) {
+      references.push(normalizedUrl.substring(1)); // Remove leading slash
     }
-    if (!url.startsWith('./') && !url.startsWith('/')) {
-      references.push('./' + url); // Add leading ./
+    if (!normalizedUrl.startsWith('./') && !normalizedUrl.startsWith('/')) {
+      references.push('./' + normalizedUrl); // Add leading ./
     }
   }
 
@@ -6187,7 +6568,7 @@ class AccessibilityFixer {
     for (const pattern of patterns) {
       let match;
       while ((match = pattern.exec(content)) !== null) {
-        const url = match[1];
+        const url = this.normalizeReferenceUrl(match[1]);
         if (this.isLocalFile(url)) {
           this.addNormalizedUrl(references, url);
         }
@@ -6213,15 +6594,15 @@ class AccessibilityFixer {
       // XMLHttpRequest
       /\.open\s*\(\s*["'][^"']*["']\s*,\s*["']([^"']+)["']/gi,
       // String literals that look like paths
-      /["']([^"']*\.(html|css|js|json|xml|jpg|jpeg|png|gif|svg|webp|ico))["']/gi,
+      /["']([^"']*\.(html|css|js|json|xml|jpg|jpeg|png|gif|svg|webp|ico)(?:[?#][^"']*)?)["']/gi,
       // Template literals with paths
-      /`([^`]*\.(html|css|js|json|xml|jpg|jpeg|png|gif|svg|webp|ico))`/gi
+      /`([^`]*\.(html|css|js|json|xml|jpg|jpeg|png|gif|svg|webp|ico)(?:[?#][^`]*)?)`/gi
     ];
     
     for (const pattern of patterns) {
       let match;
       while ((match = pattern.exec(content)) !== null) {
-        const url = match[1];
+        const url = this.normalizeReferenceUrl(match[1]);
         if (this.isLocalFile(url)) {
           this.addNormalizedUrl(references, url);
         }
@@ -6321,7 +6702,7 @@ class AccessibilityFixer {
     for (const pattern of patterns) {
       let match;
       while ((match = pattern.exec(content)) !== null) {
-        const url = match[1];
+        const url = this.normalizeReferenceUrl(match[1]);
         if (this.isLocalFile(url)) {
           this.addNormalizedUrl(references, url);
         }
@@ -6353,7 +6734,7 @@ class AccessibilityFixer {
     for (const pattern of patterns) {
       let match;
       while ((match = pattern.exec(content)) !== null) {
-        const url = match[1];
+        const url = this.normalizeReferenceUrl(match[1]);
         if (this.isLocalFile(url)) {
           this.addNormalizedUrl(references, url);
         }
@@ -6487,13 +6868,18 @@ class AccessibilityFixer {
   }
 
   isLocalFile(url) {
-    return !url.startsWith('http://') && 
-           !url.startsWith('https://') && 
-           !url.startsWith('//') &&
-           !url.startsWith('data:') &&
-           !url.startsWith('mailto:') &&
-           !url.startsWith('tel:') &&
-           !url.startsWith('#');
+    const normalizedUrl = this.normalizeReferenceUrl(url);
+    if (!normalizedUrl) {
+      return false;
+    }
+
+    return !normalizedUrl.startsWith('http://') && 
+           !normalizedUrl.startsWith('https://') && 
+           !normalizedUrl.startsWith('//') &&
+           !normalizedUrl.startsWith('data:') &&
+           !normalizedUrl.startsWith('mailto:') &&
+           !normalizedUrl.startsWith('tel:') &&
+           !normalizedUrl.startsWith('#');
   }
 
   resolveFilePath(url, baseDir) {
@@ -7167,9 +7553,14 @@ class AccessibilityFixer {
       // Extract file references from JSON values
       const extractFromObject = (obj) => {
         if (typeof obj === 'string') {
+          const normalizedValue = this.normalizeReferenceUrl(obj);
+          if (!normalizedValue) {
+            return;
+          }
+
           // Check if it looks like a file path
-          if (obj.includes('.') && (obj.includes('/') || obj.includes('\\'))) {
-            const resolved = this.resolveFilePath(obj, baseDir);
+          if (/\.(html?|css|js|json|xml|jpe?g|png|gif|svg|webp|ico)$/i.test(normalizedValue)) {
+            const resolved = this.resolveFilePath(normalizedValue, baseDir);
             if (resolved) {
               references.push(resolved);
             }
@@ -7208,7 +7599,7 @@ class AccessibilityFixer {
     patterns.forEach(pattern => {
       let match;
       while ((match = pattern.exec(content)) !== null) {
-        const filePath = match[1];
+        const filePath = this.normalizeReferenceUrl(match[1]);
         
         if (this.isLocalFile(filePath)) {
           const resolved = this.resolveFilePath(filePath, baseDir);
@@ -7246,970 +7637,282 @@ class AccessibilityFixer {
     return null;
   }
 
-  // Check Meta Tags and Open Graph Protocol
-  async checkMetaTags(directory = '.') {
-    console.log(chalk.blue('🏷️  Đang kiểm tra Meta Tags và Open Graph Protocol...'));
+  /**
+   * Generate comprehensive Excel report
+   * Covers: Meta Tags, Accessibility, Forms, Buttons, Headings, Broken Links, Unused Files, File Size, GTM
+   */
+  async generateFullReport(directory = '.', outputPath = null) {
+    const ExcelJS = require('exceljs');
+    const startTime = Date.now();
     
-    const htmlFiles = await this.findHtmlFiles(directory);
-    const results = [];
+    console.log(chalk.blue('📊 Đang tạo báo cáo toàn diện...'));
+    console.log(chalk.gray(`Thư mục: ${path.resolve(directory)}`));
+    console.log('');
     
-    for (const file of htmlFiles) {
-      try {
-        const content = await fs.readFile(file, 'utf8');
-        const metaAnalysis = this.analyzeMetaTags(content, file);
-        
-        // Skip SSI include files
-        if (metaAnalysis.isIncludeFile) {
-          results.push({ 
-            file, 
-            status: 'skipped', 
-            reason: 'SSI include file',
-            metaAnalysis 
-          });
-          continue;
-        }
-        
-        if (metaAnalysis.issues.length > 0 || metaAnalysis.warnings.length > 0 || metaAnalysis.recommendations.length > 0) {
-          console.log(chalk.cyan(`\n📁 ${path.relative(directory, file)}:`));
-          
-          // Show status for required OG tags
-          if (metaAnalysis.hasOpenGraph) {
-            console.log(chalk.green(`  ✅ Open Graph Protocol: Đã cài đặt`));
-            
-            // Required OG tags status
-            metaAnalysis.requiredTags.forEach(tag => {
-              if (tag.present) {
-                console.log(chalk.green(`    ✅ ${tag.name}: ${tag.value ? (tag.value.substring(0, 50) + (tag.value.length > 50 ? '...' : '')) : '(có)'}`));
-              } else {
-                console.log(chalk.red(`    ❌ ${tag.name}: Thiếu`));
-              }
-            });
-          } else {
-            console.log(chalk.yellow(`  ⚠️ Open Graph Protocol: Chưa cài đặt`));
-          }
-          
-          // Show Twitter Card status
-          if (metaAnalysis.hasTwitterCard) {
-            console.log(chalk.green(`  ✅ Twitter Card: Đã cài đặt`));
-          }
-          
-          // Show issues (errors)
-          metaAnalysis.issues.forEach(issue => {
-            console.log(chalk.red(`  ❌ ${issue.type}: ${issue.description}`));
-            if (issue.suggestion) {
-              console.log(chalk.gray(`    💡 ${issue.suggestion}`));
-            }
-          });
-          
-          // Show warnings
-          metaAnalysis.warnings.forEach(warning => {
-            console.log(chalk.yellow(`  ⚠️ ${warning.type}: ${warning.description}`));
-            if (warning.suggestion) {
-              console.log(chalk.gray(`    💡 ${warning.suggestion}`));
-            }
-          });
-          
-          // Show recommendations (optional improvements)
-          if (metaAnalysis.recommendations.length > 0) {
-            metaAnalysis.recommendations.forEach(rec => {
-              console.log(chalk.blue(`  💎 ${rec.type}: ${rec.description}`));
-              if (rec.suggestion) {
-                console.log(chalk.gray(`    ℹ️ ${rec.suggestion}`));
-              }
-            });
-          }
-        }
-        
-        results.push({ 
-          file, 
-          status: 'analyzed', 
-          metaAnalysis 
-        });
-      } catch (error) {
-        console.error(chalk.red(`❌ Lỗi khi xử lý ${file}: ${error.message}`));
-        results.push({ file, status: 'error', error: error.message });
+    // Initialize workbook
+    const workbook = new ExcelJS.Workbook();
+    workbook.creator = 'GBU Accessibility Tool';
+    workbook.created = new Date();
+    
+    // Store all results
+    const allResults = {
+      meta: [],
+      accessibility: [],
+      forms: [],
+      buttons: [],
+      headings: [],
+      brokenLinks: [],
+      missingResources: [],
+      unusedFiles: [],
+      fileSize: [],
+      gtm: [],
+      summary: {
+        totalFiles: 0,
+        totalIssues: 0,
+        totalWarnings: 0,
+        totalRecommendations: 0
       }
-    }
+    };
     
-    const filesAnalyzed = results.filter(r => r.status === 'analyzed').length;
-    const filesSkipped = results.filter(r => r.status === 'skipped').length;
-    const filesWithOG = results.filter(r => r.metaAnalysis?.hasOpenGraph).length;
-    const filesWithIssues = results.filter(r => r.metaAnalysis?.issues?.length > 0).length;
-    const filesWithWarnings = results.filter(r => r.metaAnalysis?.warnings?.length > 0).length;
-    const filesWithRecs = results.filter(r => r.metaAnalysis?.recommendations?.length > 0).length;
-    const totalIssues = results.reduce((sum, r) => sum + (r.metaAnalysis?.issues?.length || 0), 0);
-    const totalWarnings = results.reduce((sum, r) => sum + (r.metaAnalysis?.warnings?.length || 0), 0);
-    const totalRecs = results.reduce((sum, r) => sum + (r.metaAnalysis?.recommendations?.length || 0), 0);
+    // Style definitions
+    const headerStyle = {
+      font: { bold: true, color: { argb: 'FFFFFFFF' } },
+      fill: { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FF4472C4' } },
+      alignment: { horizontal: 'center', vertical: 'middle' },
+      border: {
+        top: { style: 'thin' },
+        left: { style: 'thin' },
+        bottom: { style: 'thin' },
+        right: { style: 'thin' }
+      }
+    };
     
-    console.log(chalk.blue(`\n📊 Tóm tắt: Đã phân tích ${filesAnalyzed} file`));
-    if (filesSkipped > 0) {
-      console.log(chalk.gray(`  ⏭️ Bỏ qua: ${filesSkipped} file (SSI include)`));
-    }
-    console.log(chalk.green(`  ✅ File có Open Graph: ${filesWithOG}`));
-    if (totalIssues > 0) {
-      console.log(chalk.red(`  ❌ File có lỗi: ${filesWithIssues} (${totalIssues} vấn đề)`));
-    }
-    if (totalWarnings > 0) {
-      console.log(chalk.yellow(`  ⚠️ File có cảnh báo: ${filesWithWarnings} (${totalWarnings} cảnh báo)`));
-    }
-    if (totalRecs > 0) {
-      console.log(chalk.blue(`  💎 File có khuyến nghị: ${filesWithRecs} (${totalRecs} khuyến nghị)`));
-    }
-    console.log(chalk.gray('💡 Open Graph Protocol cần có 4 thẻ bắt buộc: og:title, og:type, og:image, og:url'));
+    const errorStyle = {
+      font: { color: { argb: 'FFFF0000' } },
+      fill: { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFFFC7CE' } }
+    };
     
-    return results;
-  }
-
-  analyzeMetaTags(content, filePath) {
-    const result = {
-      hasOpenGraph: false,
-      hasTwitterCard: false,
-      hasBasicMeta: false,
-      isIncludeFile: false, // New: track if this is an SSI include file
-      requiredTags: [],
-      optionalTags: [],
-      twitterTags: [],
-      basicTags: [],
-      issues: [],
-      warnings: [],
-      recommendations: [], // New: optional improvements, not errors
-      syntaxErrors: [],
-      typos: [] // New: track typos for auto-fix
+    const warningStyle = {
+      font: { color: { argb: 'FF9C5700' } },
+      fill: { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFFFEB9C' } }
     };
     
-    // Check if this is an SSI include file or partial file (should be skipped)
-    // Method 1: File contains SSI include directive
-    const ssiIncludePattern = /<!--#include\s+(virtual|file)\s*=\s*["'][^"']+["']\s*-->/i;
-    if (ssiIncludePattern.test(content)) {
-      result.isIncludeFile = true;
-      result.skipReason = 'Chứa SSI include directive';
-      return result; // Skip analysis for include files
-    }
-    
-    // Method 2: File path contains /inc/ directory (common pattern for partials)
-    if (filePath && /[\/\\]inc[\/\\]/i.test(filePath)) {
-      result.isIncludeFile = true;
-      result.skipReason = 'File partial trong thư mục /inc/';
-      return result;
-    }
-    
-    // Method 3: File doesn't have DOCTYPE or <html> tag (likely a partial)
-    const hasDoctype = /<!DOCTYPE\s+html/i.test(content);
-    const hasHtmlTag = /<html[\s>]/i.test(content);
-    if (!hasDoctype && !hasHtmlTag) {
-      result.isIncludeFile = true;
-      result.skipReason = 'File partial (không có DOCTYPE/html)';
-      return result;
-    }
-    
-    // Required OG Tags according to Open Graph Protocol
-    const requiredOGTags = ['og:title', 'og:type', 'og:image', 'og:url'];
-    const optionalOGTags = ['og:description', 'og:site_name', 'og:locale', 'og:image:width', 'og:image:height', 'og:image:alt', 'og:image:secure_url', 'og:audio', 'og:video', 'og:determiner'];
-    const twitterCardTags = ['twitter:card', 'twitter:title', 'twitter:description', 'twitter:image', 'twitter:site', 'twitter:creator'];
-    const basicMetaTags = ['description', 'keywords', 'author', 'viewport', 'robots'];
-    
-    // All valid OG property names for typo detection
-    const allValidOGProperties = [
-      'og:title', 'og:type', 'og:image', 'og:url', 'og:description', 'og:site_name',
-      'og:locale', 'og:locale:alternate', 'og:audio', 'og:video', 'og:determiner',
-      'og:image:url', 'og:image:secure_url', 'og:image:type', 'og:image:width', 'og:image:height', 'og:image:alt',
-      'og:video:url', 'og:video:secure_url', 'og:video:type', 'og:video:width', 'og:video:height',
-      'og:audio:url', 'og:audio:secure_url', 'og:audio:type',
-      // Article type
-      'article:published_time', 'article:modified_time', 'article:expiration_time', 'article:author', 'article:section', 'article:tag',
-      // Profile type  
-      'profile:first_name', 'profile:last_name', 'profile:username', 'profile:gender',
-      // Book type
-      'book:author', 'book:isbn', 'book:release_date', 'book:tag',
-      // Music type
-      'music:duration', 'music:album', 'music:album:disc', 'music:album:track', 'music:musician', 'music:song', 'music:song:disc', 'music:song:track', 'music:release_date', 'music:creator',
-      // Video type
-      'video:actor', 'video:actor:role', 'video:director', 'video:writer', 'video:duration', 'video:release_date', 'video:tag', 'video:series'
-    ];
-    
-    // All valid Twitter Card property names for typo detection
-    const allValidTwitterProperties = [
-      'twitter:card', 'twitter:site', 'twitter:site:id', 'twitter:creator', 'twitter:creator:id',
-      'twitter:title', 'twitter:description', 'twitter:image', 'twitter:image:alt',
-      // Player card
-      'twitter:player', 'twitter:player:width', 'twitter:player:height', 'twitter:player:stream',
-      // App card
-      'twitter:app:name:iphone', 'twitter:app:id:iphone', 'twitter:app:url:iphone',
-      'twitter:app:name:ipad', 'twitter:app:id:ipad', 'twitter:app:url:ipad',
-      'twitter:app:name:googleplay', 'twitter:app:id:googleplay', 'twitter:app:url:googleplay',
-      'twitter:app:country'
-    ];
+    const recommendationStyle = {
+      font: { color: { argb: 'FF0070C0' } },
+      fill: { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFDDEBF7' } }
+    };
     
-    // Common typos mapping to correct property names
-    const typoCorrections = {
-      // og:site_name typos
-      'og:sitename': 'og:site_name',
-      'og:site-name': 'og:site_name',
-      'og:site_nam': 'og:site_name',
-      'og:sie_name': 'og:site_name',
-      'og:site_nmae': 'og:site_name',
-      'og:sitname': 'og:site_name',
-      'og:stie_name': 'og:site_name',
-      // og:title typos
-      'og:titel': 'og:title',
-      'og:tittle': 'og:title',
-      'og:tite': 'og:title',
-      'og:tile': 'og:title',
-      // og:type typos
-      'og:tpye': 'og:type',
-      'og:tyep': 'og:type',
-      'og:typ': 'og:type',
-      // og:image typos
-      'og:imge': 'og:image',
-      'og:iamge': 'og:image',
-      'og:img': 'og:image',
-      'og:imag': 'og:image',
-      'og:imagee': 'og:image',
-      // og:url typos
-      'og:rul': 'og:url',
-      'og:uri': 'og:url',
-      'og:ulr': 'og:url',
-      // og:description typos
-      'og:desc': 'og:description',
-      'og:descripton': 'og:description',
-      'og:desciption': 'og:description',
-      'og:descripion': 'og:description',
-      'og:descriptoin': 'og:description',
-      // og:locale typos
-      'og:local': 'og:locale',
-      'og:locael': 'og:locale',
-      'og:lcoale': 'og:locale',
-      // og:image dimensions typos
-      'og:image_width': 'og:image:width',
-      'og:image_height': 'og:image:height',
-      'og:imagewidth': 'og:image:width',
-      'og:imageheight': 'og:image:height',
-      'og:image-width': 'og:image:width',
-      'og:image-height': 'og:image:height',
-      // og:image:alt typos
-      'og:image_alt': 'og:image:alt',
-      'og:imagealt': 'og:image:alt',
-      'og:image-alt': 'og:image:alt',
-      // og:video typos
-      'og:vedio': 'og:video',
-      'og:vidoe': 'og:video',
-      // og:audio typos
-      'og:aduio': 'og:audio',
-      'og:auido': 'og:audio',
-      // Twitter card typos
-      'twitter:crad': 'twitter:card',
-      'twitter:card_type': 'twitter:card',
-      'twitter:titel': 'twitter:title',
-      'twitter:tittle': 'twitter:title',
-      'twitter:desc': 'twitter:description',
-      'twitter:img': 'twitter:image',
-      'twitter:imge': 'twitter:image',
-      'twitter:sit': 'twitter:site',
-      'twitter:autor': 'twitter:creator',
-      'twitter:author': 'twitter:creator'
+    const successStyle = {
+      font: { color: { argb: 'FF006100' } },
+      fill: { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFC6EFCE' } }
     };
+
+    // ============ SUMMARY SHEET ============
+    const summarySheet = workbook.addWorksheet('📋 Summary', { 
+      properties: { tabColor: { argb: 'FF4472C4' } } 
+    });
     
-    // Valid og:type values
-    const validOGTypes = [
-      'website', 'article', 'book', 'profile', 'video.movie', 'video.episode', 
-      'video.tv_show', 'video.other', 'music.song', 'music.album', 'music.playlist',
-      'music.radio_station', 'product', 'place', 'business.business'
+    summarySheet.columns = [
+      { header: 'Thống kê', key: 'stat', width: 35 },
+      { header: 'Giá trị', key: 'value', width: 20 }
     ];
     
-    // Valid twitter:card values
-    const validTwitterCards = ['summary', 'summary_large_image', 'app', 'player'];
-    
-    // Extract all meta tags
-    const metaTagPattern = /<meta\s+([^>]+)>/gi;
-    let match;
-    const allMetaTags = [];
-    
-    while ((match = metaTagPattern.exec(content)) !== null) {
-      const attributes = match[1];
-      const tag = this.parseMetaTagAttributes(attributes);
-      tag.raw = match[0];
-      tag.index = match.index; // Track position for fixing
-      allMetaTags.push(tag);
-    }
-    
-    // Check for typos in OG and Twitter property names
-    allMetaTags.forEach(tag => {
-      const propertyName = tag.property || tag.name;
-      if (!propertyName) return;
-      
-      const propertyLower = propertyName.toLowerCase();
-      
-      // Check if it looks like an OG or Twitter tag
-      if (propertyLower.startsWith('og:') || propertyLower.startsWith('twitter:')) {
-        // Step 1: Check against known common typos first (fast lookup)
-        if (typoCorrections[propertyLower]) {
-          const correctProperty = typoCorrections[propertyLower];
-          result.typos.push({
-            found: propertyName,
-            expected: correctProperty,
-            raw: tag.raw,
-            content: tag.content,
-            isProperty: !!tag.property, // Was it using property="" or name=""?
-            index: tag.index
-          });
-          
-          result.issues.push({
-            type: 'Lỗi chính tả OG/Twitter',
-            description: `"${propertyName}" có vẻ là lỗi chính tả của "${correctProperty}"`,
-            suggestion: `Sửa thành: <meta property="${correctProperty}" content="${tag.content || '...'}">`
-          });
-        }
-        // Step 2: Check if property is not in valid list - find closest match
-        else {
-          let isValid = false;
-          let validList = [];
-          
-          if (propertyLower.startsWith('og:')) {
-            isValid = allValidOGProperties.includes(propertyLower);
-            validList = allValidOGProperties;
-          } else if (propertyLower.startsWith('twitter:')) {
-            isValid = allValidTwitterProperties.includes(propertyLower);
-            validList = allValidTwitterProperties;
-          }
-          
-          // If not valid, find closest match using Levenshtein distance
-          if (!isValid) {
-            const closestMatch = this.findClosestOGProperty(propertyLower, validList);
-            
-            // Use dynamic threshold based on property length
-            // Shorter properties need smaller distance, longer can have bigger
-            const maxDistance = Math.max(2, Math.floor(propertyLower.length * 0.3));
-            
-            if (closestMatch && closestMatch.distance <= maxDistance) {
-              result.typos.push({
-                found: propertyName,
-                expected: closestMatch.property,
-                raw: tag.raw,
-                content: tag.content,
-                isProperty: !!tag.property,
-                index: tag.index,
-                distance: closestMatch.distance
-              });
-              
-              // If very close (distance 1-2), treat as definite typo (error)
-              if (closestMatch.distance <= 2) {
-                result.issues.push({
-                  type: 'Lỗi chính tả OG/Twitter',
-                  description: `"${propertyName}" là lỗi chính tả của "${closestMatch.property}"`,
-                  suggestion: `Sửa thành: <meta property="${closestMatch.property}" content="${tag.content || '...'}">`
-                });
-              } else {
-                // If further away (distance 3+), treat as warning (possible typo)
-                result.warnings.push({
-                  type: 'Property không hợp lệ',
-                  description: `"${propertyName}" không phải là property chuẩn. Có thể bạn muốn dùng "${closestMatch.property}"?`,
-                  suggestion: `Sửa thành: <meta property="${closestMatch.property}" content="${tag.content || '...'}">`
-                });
-              }
-            } else {
-              // No close match found - report as unknown property
-              result.warnings.push({
-                type: 'Property không xác định',
-                description: `"${propertyName}" không phải là property OG/Twitter chuẩn`,
-                suggestion: `Kiểm tra tên property. Tham khảo: https://ogp.me/ hoặc https://developer.twitter.com/en/docs/twitter-for-websites/cards`
-              });
-            }
-          }
-        }
-      }
-    });
-    
-    // Check for basic meta tags
-    basicMetaTags.forEach(tagName => {
-      const tag = allMetaTags.find(t => t.name === tagName);
-      result.basicTags.push({
-        name: tagName,
-        present: !!tag,
-        value: tag?.content || null
-      });
-      
-      if (tag) {
-        result.hasBasicMeta = true;
-      }
+    summarySheet.getRow(1).eachCell(cell => {
+      cell.style = headerStyle;
     });
-    
-    // Check description meta tag
-    const descriptionTag = allMetaTags.find(t => t.name === 'description');
-    if (!descriptionTag) {
-      result.warnings.push({
-        type: 'Thiếu Meta Description',
-        description: 'Không tìm thấy thẻ meta description',
-        suggestion: 'Thêm <meta name="description" content="Mô tả trang web của bạn">'
-      });
-    } else if (!descriptionTag.content || descriptionTag.content.length < 50) {
-      result.warnings.push({
-        type: 'Meta Description ngắn',
-        description: `Meta description chỉ có ${descriptionTag.content?.length || 0} ký tự`,
-        suggestion: 'Meta description nên có độ dài 50-160 ký tự để tối ưu SEO'
-      });
-    } else if (descriptionTag.content.length > 160) {
-      result.warnings.push({
-        type: 'Meta Description dài',
-        description: `Meta description có ${descriptionTag.content.length} ký tự, vượt quá 160 ký tự`,
-        suggestion: 'Meta description nên có độ dài 50-160 ký tự để hiển thị đầy đủ trên Google'
-      });
-    }
-    
-    // Check viewport meta tag
-    const viewportTag = allMetaTags.find(t => t.name === 'viewport');
-    if (!viewportTag) {
-      result.warnings.push({
-        type: 'Thiếu Viewport',
-        description: 'Không tìm thấy thẻ meta viewport',
-        suggestion: 'Thêm <meta name="viewport" content="width=device-width, initial-scale=1.0">'
-      });
-    }
-    
-    // Check for Open Graph tags
-    requiredOGTags.forEach(tagName => {
-      // Check for correct syntax (property attribute, not name)
-      const correctTag = allMetaTags.find(t => t.property === tagName);
-      const wrongSyntaxTag = allMetaTags.find(t => t.name === tagName);
+
+    // ============ 1. META TAGS CHECK ============
+    console.log(chalk.blue('🏷️  Đang kiểm tra Meta Tags...'));
+    try {
+      const metaResults = await this.checkMetaTagsForReport(directory);
+      allResults.meta = metaResults;
       
-      const tagInfo = {
-        name: tagName,
-        present: !!correctTag,
-        value: correctTag?.content || null,
-        wrongSyntax: !!wrongSyntaxTag && !correctTag
-      };
+      const metaSheet = workbook.addWorksheet('🏷️ Meta Tags');
+      metaSheet.columns = [
+        { header: 'File', key: 'file', width: 50 },
+        { header: 'Loại', key: 'type', width: 15 },
+        { header: 'Vấn đề', key: 'issue', width: 40 },
+        { header: 'Mô tả', key: 'description', width: 50 },
+        { header: 'Đề xuất', key: 'suggestion', width: 60 },
+        { header: 'Mức độ', key: 'severity', width: 15 }
+      ];
       
-      result.requiredTags.push(tagInfo);
+      metaSheet.getRow(1).eachCell(cell => {
+        cell.style = headerStyle;
+      });
       
-      if (correctTag) {
-        result.hasOpenGraph = true;
+      for (const result of metaResults) {
+        if (result.status === 'skipped') continue;
         
-        // Validate content
-        if (!correctTag.content || correctTag.content.trim() === '') {
-          result.issues.push({
-            type: 'Giá trị rỗng',
-            description: `${tagName} không có giá trị`,
-            suggestion: `Thêm giá trị cho thuộc tính content của ${tagName}`
-          });
-        }
+        const relativePath = path.relative(directory, result.file);
         
-        // Specific validations
-        if (tagName === 'og:type' && !validOGTypes.includes(correctTag.content?.toLowerCase())) {
-          result.warnings.push({
-            type: 'og:type không hợp lệ',
-            description: `Giá trị "${correctTag.content}" không phải là og:type chuẩn`,
-            suggestion: `Sử dụng một trong các giá trị: ${validOGTypes.slice(0, 5).join(', ')}...`
+        for (const issue of (result.metaAnalysis?.issues || [])) {
+          const row = metaSheet.addRow({
+            file: relativePath,
+            type: 'Error',
+            issue: issue.type,
+            description: issue.description,
+            suggestion: issue.suggestion || '',
+            severity: '❌ Lỗi'
           });
+          row.getCell('severity').style = errorStyle;
+          allResults.summary.totalIssues++;
         }
         
-        if (tagName === 'og:url') {
-          if (correctTag.content && !correctTag.content.match(/^https?:\/\//)) {
-            result.issues.push({
-              type: 'og:url không hợp lệ',
-              description: 'og:url phải là URL tuyệt đối (bắt đầu bằng http:// hoặc https://)',
-              suggestion: 'Sử dụng URL đầy đủ: https://example.com/path'
-            });
-          }
-        }
-        
-        if (tagName === 'og:image') {
-          if (correctTag.content && !correctTag.content.match(/^https?:\/\//)) {
-            result.warnings.push({
-              type: 'og:image không phải URL tuyệt đối',
-              description: 'og:image nên là URL tuyệt đối để hoạt động tốt trên các nền tảng',
-              suggestion: 'Sử dụng URL đầy đủ: https://example.com/images/og-image.jpg'
-            });
-          }
+        for (const warning of (result.metaAnalysis?.warnings || [])) {
+          const row = metaSheet.addRow({
+            file: relativePath,
+            type: 'Warning',
+            issue: warning.type,
+            description: warning.description,
+            suggestion: warning.suggestion || '',
+            severity: '⚠️ Cảnh báo'
+          });
+          row.getCell('severity').style = warningStyle;
+          allResults.summary.totalWarnings++;
         }
         
-        if (tagName === 'og:title') {
-          if (correctTag.content && correctTag.content.length > 60) {
-            result.warnings.push({
-              type: 'og:title dài',
-              description: `og:title có ${correctTag.content.length} ký tự, nên dưới 60 ký tự`,
-              suggestion: 'Rút gọn tiêu đề để hiển thị đầy đủ trên các nền tảng'
-            });
-          }
+        for (const rec of (result.metaAnalysis?.recommendations || [])) {
+          const row = metaSheet.addRow({
+            file: relativePath,
+            type: 'Recommendation',
+            issue: rec.type,
+            description: rec.description,
+            suggestion: rec.suggestion || '',
+            severity: '💎 Khuyến nghị'
+          });
+          row.getCell('severity').style = recommendationStyle;
+          allResults.summary.totalRecommendations++;
         }
-        
-      } else if (wrongSyntaxTag) {
-        // Wrong syntax detected - track for auto-fix
-        result.syntaxErrors.push({
-          tag: tagName,
-          found: `name="${tagName}"`,
-          expected: `property="${tagName}"`,
-          raw: wrongSyntaxTag.raw,
-          content: wrongSyntaxTag.content,
-          index: wrongSyntaxTag.index
-        });
-        
-        result.issues.push({
-          type: 'Sai cú pháp OG',
-          description: `${tagName} sử dụng name="" thay vì property=""`,
-          suggestion: `Thay đổi từ <meta name="${tagName}" ...> thành <meta property="${tagName}" ...>`
-        });
-      } else {
-        result.issues.push({
-          type: 'Thiếu thẻ OG bắt buộc',
-          description: `Thiếu ${tagName}`,
-          suggestion: `Thêm <meta property="${tagName}" content="...">`
-        });
-      }
-    });
-    
-    // Check optional OG tags
-    optionalOGTags.forEach(tagName => {
-      const tag = allMetaTags.find(t => t.property === tagName);
-      result.optionalTags.push({
-        name: tagName,
-        present: !!tag,
-        value: tag?.content || null
-      });
-    });
-    
-    // Check og:image dimensions - these are recommendations, not required
-    const ogImage = allMetaTags.find(t => t.property === 'og:image');
-    if (ogImage) {
-      const ogImageWidth = allMetaTags.find(t => t.property === 'og:image:width');
-      const ogImageHeight = allMetaTags.find(t => t.property === 'og:image:height');
-      const ogImageAlt = allMetaTags.find(t => t.property === 'og:image:alt');
-      
-      if (!ogImageWidth || !ogImageHeight) {
-        result.recommendations.push({
-          type: 'Kích thước og:image',
-          description: 'Cân nhắc thêm kích thước hình ảnh og:image',
-          suggestion: 'Thêm og:image:width và og:image:height để tối ưu hiển thị. Khuyến nghị: 1200x630 pixels'
-        });
       }
       
-      if (!ogImageAlt) {
-        result.recommendations.push({
-          type: 'og:image:alt',
-          description: 'Cân nhắc thêm alt text cho og:image',
-          suggestion: 'Thêm <meta property="og:image:alt" content="Mô tả hình ảnh"> để cải thiện accessibility'
-        });
-      }
+      metaSheet.autoFilter = 'A1:F1';
+      console.log(chalk.green(`  ✅ Meta Tags: ${metaResults.filter(r => r.status === 'analyzed').length} file`));
+    } catch (error) {
+      console.log(chalk.yellow(`  ⚠️ Meta Tags: ${error.message}`));
     }
-    
-    // Check for Twitter Card tags
-    twitterCardTags.forEach(tagName => {
-      const tag = allMetaTags.find(t => t.name === tagName || t.property === tagName);
-      result.twitterTags.push({
-        name: tagName,
-        present: !!tag,
-        value: tag?.content || null
+
+    // ============ 2. ACCESSIBILITY CHECK ============
+    console.log(chalk.blue('♿ Đang kiểm tra Accessibility (Alt, Aria)...'));
+    try {
+      const accessResults = await this.checkAccessibilityForReport(directory);
+      allResults.accessibility = accessResults;
+      
+      const accessSheet = workbook.addWorksheet('♿ Accessibility');
+      accessSheet.columns = [
+        { header: 'File', key: 'file', width: 50 },
+        { header: 'Loại lỗi', key: 'type', width: 20 },
+        { header: 'Mô tả', key: 'description', width: 60 },
+        { header: 'Element', key: 'element', width: 40 },
+        { header: 'Mức độ', key: 'severity', width: 15 }
+      ];
+      
+      accessSheet.getRow(1).eachCell(cell => {
+        cell.style = headerStyle;
       });
       
-      if (tag) {
-        result.hasTwitterCard = true;
-        
-        // Validate twitter:card value
-        if (tagName === 'twitter:card' && !validTwitterCards.includes(tag.content?.toLowerCase())) {
-          result.issues.push({
-            type: 'twitter:card không hợp lệ',
-            description: `Giá trị "${tag.content}" không phải là twitter:card hợp lệ`,
-            suggestion: `Sử dụng một trong các giá trị: ${validTwitterCards.join(', ')}`
+      for (const result of accessResults) {
+        const relativePath = path.relative(directory, result.file);
+        for (const issue of (result.issues || [])) {
+          const row = accessSheet.addRow({
+            file: relativePath,
+            type: issue.type,
+            description: issue.description,
+            element: issue.element || '',
+            severity: '❌ Lỗi'
           });
+          row.getCell('severity').style = errorStyle;
+          allResults.summary.totalIssues++;
         }
       }
-    });
-    
-    // Suggest Twitter Card if OG exists but Twitter Card doesn't
-    if (result.hasOpenGraph && !result.hasTwitterCard) {
-      result.warnings.push({
-        type: 'Thiếu Twitter Card',
-        description: 'Đã có Open Graph nhưng chưa có Twitter Card',
-        suggestion: 'Thêm Twitter Card để tối ưu hiển thị trên Twitter. Ví dụ: <meta name="twitter:card" content="summary_large_image">'
-      });
-    }
-    
-    // Check for canonical URL - this is a recommendation, not required
-    const canonicalPattern = /<link\s+[^>]*rel\s*=\s*["']canonical["'][^>]*>/i;
-    const canonicalMatch = content.match(canonicalPattern);
-    if (!canonicalMatch) {
-      result.recommendations.push({
-        type: 'Canonical URL',
-        description: 'Chưa có thẻ link rel="canonical"',
-        suggestion: 'Cân nhắc thêm <link rel="canonical" href="..."> để tránh duplicate content'
-      });
-    }
-    
-    // Check title tag
-    const titlePattern = /<title[^>]*>([^<]*)<\/title>/i;
-    const titleMatch = content.match(titlePattern);
-    if (!titleMatch || !titleMatch[1] || titleMatch[1].trim() === '') {
-      result.issues.push({
-        type: 'Thiếu hoặc rỗng Title',
-        description: 'Thẻ <title> không có hoặc rỗng',
-        suggestion: 'Thêm tiêu đề cho trang: <title>Tiêu đề trang</title>'
-      });
-    } else if (titleMatch[1].length > 60) {
-      result.warnings.push({
-        type: 'Title dài',
-        description: `Title có ${titleMatch[1].length} ký tự, nên dưới 60 ký tự`,
-        suggestion: 'Rút gọn tiêu đề để hiển thị đầy đủ trên Google'
-      });
-    }
-    
-    // Check consistency between title and og:title
-    const ogTitle = allMetaTags.find(t => t.property === 'og:title');
-    if (titleMatch && ogTitle && titleMatch[1].trim() && ogTitle.content) {
-      if (titleMatch[1].trim().toLowerCase() !== ogTitle.content.toLowerCase()) {
-        // This is actually okay, just noting it
-        // Different titles for different purposes can be intentional
-      }
-    }
-    
-    return result;
-  }
-
-  // Find closest matching OG property using Levenshtein distance
-  findClosestOGProperty(typo, validProperties) {
-    let minDistance = Infinity;
-    let closestProperty = null;
-    
-    for (const property of validProperties) {
-      const distance = this.levenshteinDistance(typo, property);
-      if (distance < minDistance) {
-        minDistance = distance;
-        closestProperty = property;
-      }
-    }
-    
-    return { property: closestProperty, distance: minDistance };
-  }
-
-  // Levenshtein distance algorithm for typo detection
-  levenshteinDistance(str1, str2) {
-    const m = str1.length;
-    const n = str2.length;
-    
-    // Create a matrix
-    const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
-    
-    // Initialize first row and column
-    for (let i = 0; i <= m; i++) dp[i][0] = i;
-    for (let j = 0; j <= n; j++) dp[0][j] = j;
-    
-    // Fill the matrix
-    for (let i = 1; i <= m; i++) {
-      for (let j = 1; j <= n; j++) {
-        if (str1[i - 1] === str2[j - 1]) {
-          dp[i][j] = dp[i - 1][j - 1];
-        } else {
-          dp[i][j] = 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
-        }
-      }
+      
+      accessSheet.autoFilter = 'A1:E1';
+      console.log(chalk.green(`  ✅ Accessibility: ${accessResults.length} file có vấn đề`));
+    } catch (error) {
+      console.log(chalk.yellow(`  ⚠️ Accessibility: ${error.message}`));
     }
-    
-    return dp[m][n];
-  }
 
-  // Auto-fix Meta Tags
-  async fixMetaTags(directory = '.') {
-    console.log(chalk.blue('🔧 Đang sửa Meta Tags và Open Graph Protocol...'));
-    
-    const htmlFiles = await this.findHtmlFiles(directory);
-    const results = [];
-    
-    for (const file of htmlFiles) {
-      try {
-        let content = await fs.readFile(file, 'utf8');
-        const originalContent = content;
-        const metaAnalysis = this.analyzeMetaTags(content, file);
-        
-        // Skip SSI include files
-        if (metaAnalysis.isIncludeFile) {
-          results.push({
-            file,
-            status: 'skipped',
-            reason: 'SSI include file',
-            fixes: 0
-          });
-          continue;
-        }
-        
-        let fixCount = 0;
-        const fixes = [];
-        
-        // Fix typos in OG/Twitter property names
-        if (metaAnalysis.typos.length > 0) {
-          for (const typo of metaAnalysis.typos) {
-            const attribute = typo.isProperty ? 'property' : 'name';
-            // Create the corrected meta tag
-            const correctedTag = `<meta property="${typo.expected}" content="${typo.content || ''}">`;
-            
-            // Replace the typo with the correct tag
-            content = content.replace(typo.raw, correctedTag);
-            fixCount++;
-            fixes.push({
-              type: 'Sửa lỗi chính tả',
-              from: typo.found,
-              to: typo.expected
-            });
-          }
-        }
-        
-        // Fix syntax errors (name="" -> property="" for OG tags)
-        if (metaAnalysis.syntaxErrors.length > 0) {
-          for (const error of metaAnalysis.syntaxErrors) {
-            // Create the corrected meta tag with property instead of name
-            const correctedTag = `<meta property="${error.tag}" content="${error.content || ''}">`;
-            
-            // Replace the wrong syntax with the correct one
-            content = content.replace(error.raw, correctedTag);
-            fixCount++;
-            fixes.push({
-              type: 'Sửa cú pháp OG',
-              from: `name="${error.tag}"`,
-              to: `property="${error.tag}"`
-            });
-          }
-        }
-        
-        // Save the file if changes were made
-        if (fixCount > 0 && content !== originalContent) {
-          if (!this.config.dryRun) {
-            if (this.config.backupFiles) {
-              await fs.writeFile(file + '.backup', originalContent);
-            }
-            await fs.writeFile(file, content);
-          }
-          
-          console.log(chalk.cyan(`\n📁 ${path.relative(directory, file)}:`));
-          console.log(chalk.green(`  ✅ Đã sửa ${fixCount} vấn đề:`));
-          fixes.forEach(fix => {
-            console.log(chalk.gray(`    - ${fix.type}: ${fix.from} → ${fix.to}`));
-          });
-          
-          results.push({
-            file,
-            status: 'fixed',
-            fixes: fixCount,
-            details: fixes
-          });
-        } else if (fixCount === 0 && (metaAnalysis.typos.length > 0 || metaAnalysis.syntaxErrors.length > 0)) {
-          results.push({
-            file,
-            status: 'no-changes',
-            fixes: 0
-          });
-        } else {
-          results.push({
-            file,
-            status: 'ok',
-            fixes: 0
+    // ============ 3. FORMS CHECK ============
+    console.log(chalk.blue('📋 Đang kiểm tra Form Labels...'));
+    try {
+      const formsResults = await this.checkFormsForReport(directory);
+      allResults.forms = formsResults;
+      
+      const formsSheet = workbook.addWorksheet('📋 Forms');
+      formsSheet.columns = [
+        { header: 'File', key: 'file', width: 50 },
+        { header: 'Loại lỗi', key: 'type', width: 25 },
+        { header: 'Mô tả', key: 'description', width: 60 },
+        { header: 'Element', key: 'element', width: 40 },
+        { header: 'Mức độ', key: 'severity', width: 15 }
+      ];
+      
+      formsSheet.getRow(1).eachCell(cell => {
+        cell.style = headerStyle;
+      });
+      
+      for (const result of formsResults) {
+        const relativePath = path.relative(directory, result.file);
+        for (const issue of (result.issues || [])) {
+          const row = formsSheet.addRow({
+            file: relativePath,
+            type: issue.type,
+            description: issue.description,
+            element: issue.element || '',
+            severity: '❌ Lỗi'
           });
+          row.getCell('severity').style = errorStyle;
+          allResults.summary.totalIssues++;
         }
-        
-      } catch (error) {
-        console.error(chalk.red(`❌ Lỗi khi xử lý ${file}: ${error.message}`));
-        results.push({ file, status: 'error', error: error.message });
       }
+      
+      formsSheet.autoFilter = 'A1:E1';
+      console.log(chalk.green(`  ✅ Forms: ${formsResults.length} file có vấn đề`));
+    } catch (error) {
+      console.log(chalk.yellow(`  ⚠️ Forms: ${error.message}`));
     }
-    
-    const filesFixed = results.filter(r => r.status === 'fixed').length;
-    const totalFixes = results.reduce((sum, r) => sum + (r.fixes || 0), 0);
-    
-    console.log(chalk.blue(`\n📊 Tóm tắt: Đã xử lý ${results.length} file`));
-    if (filesFixed > 0) {
-      console.log(chalk.green(`  ✅ Đã sửa: ${filesFixed} file (${totalFixes} vấn đề)`));
-    } else {
-      console.log(chalk.green(`  ✅ Không có lỗi cú pháp hoặc chính tả cần sửa`));
-    }
-    
-    if (this.config.dryRun) {
-      console.log(chalk.cyan('💡 Đây là chế độ xem trước. Sử dụng không có --dry-run để áp dụng thay đổi.'));
-    }
-    
-    return results;
-  }
-
-  parseMetaTagAttributes(attributeString) {
-    const result = {};
-    
-    // Parse name attribute
-    const nameMatch = attributeString.match(/name\s*=\s*["']([^"']+)["']/i);
-    if (nameMatch) {
-      result.name = nameMatch[1].toLowerCase();
-    }
-    
-    // Parse property attribute (for Open Graph)
-    const propertyMatch = attributeString.match(/property\s*=\s*["']([^"']+)["']/i);
-    if (propertyMatch) {
-      result.property = propertyMatch[1].toLowerCase();
-    }
-    
-    // Parse content attribute
-    const contentMatch = attributeString.match(/content\s*=\s*["']([^"']*)["']/i);
-    if (contentMatch) {
-      result.content = contentMatch[1];
-    }
-    
-    // Parse charset attribute
-    const charsetMatch = attributeString.match(/charset\s*=\s*["']?([^"'\s>]+)["']?/i);
-    if (charsetMatch) {
-      result.charset = charsetMatch[1];
-    }
-    
-    // Parse http-equiv attribute
-    const httpEquivMatch = attributeString.match(/http-equiv\s*=\s*["']([^"']+)["']/i);
-    if (httpEquivMatch) {
-      result.httpEquiv = httpEquivMatch[1];
-    }
-    
-    return result;
-  }
 
-  /**
-   * Generate Full Report - Tạo báo cáo Excel toàn diện
-   * Bao gồm tất cả các loại kiểm tra: Meta, Headings, Links, Unused Files, Dead Code, File Size, GTM
-   */
-  async generateFullReport(directory = '.', outputPath = null) {
-    const ExcelJS = require('exceljs');
-    const startTime = Date.now();
-    
-    console.log(chalk.blue('📊 Đang tạo báo cáo toàn diện...'));
-    console.log(chalk.gray(`Thư mục: ${path.resolve(directory)}`));
-    console.log('');
-    
-    // Initialize workbook
-    const workbook = new ExcelJS.Workbook();
-    workbook.creator = 'GBU Accessibility Tool';
-    workbook.created = new Date();
-    
-    // Store all results
-    const allResults = {
-      meta: [],
-      headings: [],
-      brokenLinks: [],
-      missingResources: [],
-      unusedFiles: [],
-      deadCode: [],
-      fileSize: [],
-      gtm: [],
-      summary: {
-        totalFiles: 0,
-        totalIssues: 0,
-        totalWarnings: 0,
-        totalRecommendations: 0
-      }
-    };
-    
-    // Style definitions
-    const headerStyle = {
-      font: { bold: true, color: { argb: 'FFFFFFFF' } },
-      fill: { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FF4472C4' } },
-      alignment: { horizontal: 'center', vertical: 'middle' },
-      border: {
-        top: { style: 'thin' },
-        left: { style: 'thin' },
-        bottom: { style: 'thin' },
-        right: { style: 'thin' }
-      }
-    };
-    
-    const errorStyle = {
-      font: { color: { argb: 'FFFF0000' } },
-      fill: { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFFFC7CE' } }
-    };
-    
-    const warningStyle = {
-      font: { color: { argb: 'FF9C5700' } },
-      fill: { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFFFEB9C' } }
-    };
-    
-    const recommendationStyle = {
-      font: { color: { argb: 'FF0070C0' } },
-      fill: { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFDDEBF7' } }
-    };
-    
-    const successStyle = {
-      font: { color: { argb: 'FF006100' } },
-      fill: { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFC6EFCE' } }
-    };
-
-    // Create Summary sheet FIRST so it appears as the first tab
-    const summarySheet = workbook.addWorksheet('📋 Summary', { 
-      properties: { tabColor: { argb: 'FF4472C4' } } 
-    });
-
-    // ============ 1. META TAGS CHECK ============
-    console.log(chalk.blue('🏷️  Đang kiểm tra Meta Tags...'));
+    // ============ 4. BUTTONS CHECK ============
+    console.log(chalk.blue('🔘 Đang kiểm tra Button Names...'));
     try {
-      const metaResults = await this.checkMetaTagsForReport(directory);
-      allResults.meta = metaResults;
+      const buttonsResults = await this.checkButtonsForReport(directory);
+      allResults.buttons = buttonsResults;
       
-      const metaSheet = workbook.addWorksheet('🏷️ Meta Tags');
-      metaSheet.columns = [
-        { header: 'File', key: 'file', width: 50 },
-        { header: 'Loại', key: 'type', width: 15 },
-        { header: 'Vấn đề', key: 'issue', width: 40 },
-        { header: 'Mô tả', key: 'description', width: 50 },
-        { header: 'Đề xuất', key: 'suggestion', width: 60 },
+      const buttonsSheet = workbook.addWorksheet('🔘 Buttons');
+      buttonsSheet.columns = [
+        { header: 'File', key: 'file', width: 50 },
+        { header: 'Loại lỗi', key: 'type', width: 25 },
+        { header: 'Mô tả', key: 'description', width: 60 },
+        { header: 'Element', key: 'element', width: 40 },
         { header: 'Mức độ', key: 'severity', width: 15 }
       ];
       
-      // Apply header style
-      metaSheet.getRow(1).eachCell(cell => {
+      buttonsSheet.getRow(1).eachCell(cell => {
         cell.style = headerStyle;
       });
       
-      let metaRowNum = 2;
-      for (const result of metaResults) {
-        if (result.status === 'skipped') continue;
-        
+      for (const result of buttonsResults) {
         const relativePath = path.relative(directory, result.file);
-        
-        // Add issues
-        for (const issue of (result.metaAnalysis?.issues || [])) {
-          const row = metaSheet.addRow({
+        for (const issue of (result.issues || [])) {
+          const row = buttonsSheet.addRow({
             file: relativePath,
-            type: 'Error',
-            issue: issue.type,
+            type: issue.type,
             description: issue.description,
-            suggestion: issue.suggestion || '',
+            element: issue.element || '',
             severity: '❌ Lỗi'
           });
           row.getCell('severity').style = errorStyle;
           allResults.summary.totalIssues++;
         }
-        
-        // Add warnings
-        for (const warning of (result.metaAnalysis?.warnings || [])) {
-          const row = metaSheet.addRow({
-            file: relativePath,
-            type: 'Warning',
-            issue: warning.type,
-            description: warning.description,
-            suggestion: warning.suggestion || '',
-            severity: '⚠️ Cảnh báo'
-          });
-          row.getCell('severity').style = warningStyle;
-          allResults.summary.totalWarnings++;
-        }
-        
-        // Add recommendations
-        for (const rec of (result.metaAnalysis?.recommendations || [])) {
-          const row = metaSheet.addRow({
-            file: relativePath,
-            type: 'Recommendation',
-            issue: rec.type,
-            description: rec.description,
-            suggestion: rec.suggestion || '',
-            severity: '💎 Khuyến nghị'
-          });
-          row.getCell('severity').style = recommendationStyle;
-          allResults.summary.totalRecommendations++;
-        }
       }
       
-      metaSheet.autoFilter = 'A1:F1';
-      console.log(chalk.green(`  ✅ Meta Tags: ${metaResults.filter(r => r.status === 'analyzed').length} file`));
+      buttonsSheet.autoFilter = 'A1:E1';
+      console.log(chalk.green(`  ✅ Buttons: ${buttonsResults.length} file có vấn đề`));
     } catch (error) {
-      console.log(chalk.yellow(`  ⚠️ Meta Tags: ${error.message}`));
+      console.log(chalk.yellow(`  ⚠️ Buttons: ${error.message}`));
     }
 
-    // ============ 2. HEADINGS CHECK ============
+    // ============ 5. HEADINGS CHECK ============
     console.log(chalk.blue('📑 Đang kiểm tra Heading Structure...'));
     try {
       const headingsResults = await this.analyzeHeadingsForReport(directory);
@@ -8254,7 +7957,7 @@ class AccessibilityFixer {
       console.log(chalk.yellow(`  ⚠️ Headings: ${error.message}`));
     }
 
-    // ============ 3. BROKEN LINKS CHECK ============
+    // ============ 6. BROKEN LINKS CHECK ============
     console.log(chalk.blue('🔗 Đang kiểm tra Broken Links...'));
     try {
       const linksResults = await this.checkBrokenLinksForReport(directory);
@@ -8304,7 +8007,7 @@ class AccessibilityFixer {
       console.log(chalk.yellow(`  ⚠️ Broken Links: ${error.message}`));
     }
 
-    // ============ 4. UNUSED FILES CHECK ============
+    // ============ 7. UNUSED FILES CHECK ============
     console.log(chalk.blue('📁 Đang kiểm tra Unused Files...'));
     try {
       const unusedResults = await this.checkUnusedFilesForReport(directory);
@@ -8323,10 +8026,14 @@ class AccessibilityFixer {
       });
       
       for (const file of unusedResults) {
+        const filePath = typeof file === 'string' ? file : file.path;
+        const fileType = (typeof file === 'object' && file.type) ? file.type : path.extname(filePath).slice(1).toUpperCase();
+        const fileSize = (typeof file === 'object' && file.size) ? this.formatFileSize(file.size) : '-';
+        
         const row = unusedSheet.addRow({
-          file: file.path || file,
-          type: file.type || path.extname(file).slice(1).toUpperCase(),
-          size: file.size ? this.formatFileSize(file.size) : '-',
+          file: filePath,
+          type: fileType,
+          size: fileSize,
           note: 'Không được tham chiếu trong project'
         });
         row.getCell('note').style = warningStyle;
@@ -8339,50 +8046,13 @@ class AccessibilityFixer {
       console.log(chalk.yellow(`  ⚠️ Unused Files: ${error.message}`));
     }
 
-    // ============ 5. DEAD CODE CHECK ============
-    console.log(chalk.blue('💀 Đang kiểm tra Dead Code...'));
-    try {
-      const deadCodeResults = await this.checkDeadCodeForReport(directory);
-      allResults.deadCode = deadCodeResults;
-      
-      const deadCodeSheet = workbook.addWorksheet('💀 Dead Code');
-      deadCodeSheet.columns = [
-        { header: 'File', key: 'file', width: 50 },
-        { header: 'Loại', key: 'type', width: 15 },
-        { header: 'Selector/Function', key: 'selector', width: 40 },
-        { header: 'Dòng', key: 'line', width: 10 },
-        { header: 'Ghi chú', key: 'note', width: 40 }
-      ];
-      
-      deadCodeSheet.getRow(1).eachCell(cell => {
-        cell.style = headerStyle;
-      });
-      
-      for (const item of deadCodeResults) {
-        const row = deadCodeSheet.addRow({
-          file: item.file || '',
-          type: item.type || 'CSS',
-          selector: item.selector || item.name || '',
-          line: item.line || '-',
-          note: 'Không được sử dụng'
-        });
-        row.getCell('note').style = warningStyle;
-        allResults.summary.totalWarnings++;
-      }
-      
-      deadCodeSheet.autoFilter = 'A1:E1';
-      console.log(chalk.green(`  ✅ Dead Code: ${deadCodeResults.length} item`));
-    } catch (error) {
-      console.log(chalk.yellow(`  ⚠️ Dead Code: ${error.message}`));
-    }
-
-    // ============ 6. FILE SIZE CHECK ============
-    console.log(chalk.blue('📦 Đang kiểm tra File Size...'));
+    // ============ 8. FILE SIZE CHECK ============
+    console.log(chalk.blue('📦 Đang kiểm tra File Size (>1MB)...'));
     try {
       const fileSizeResults = await this.checkFileSizeForReport(directory);
       allResults.fileSize = fileSizeResults;
       
-      const sizeSheet = workbook.addWorksheet('📦 File Size');
+      const sizeSheet = workbook.addWorksheet('📦 Large Files');
       sizeSheet.columns = [
         { header: 'File', key: 'file', width: 50 },
         { header: 'Loại', key: 'type', width: 15 },
@@ -8408,12 +8078,12 @@ class AccessibilityFixer {
       }
       
       sizeSheet.autoFilter = 'A1:E1';
-      console.log(chalk.green(`  ✅ File Size: ${fileSizeResults.length} file`));
+      console.log(chalk.green(`  ✅ Large Files: ${fileSizeResults.length} file`));
     } catch (error) {
       console.log(chalk.yellow(`  ⚠️ File Size: ${error.message}`));
     }
 
-    // ============ 7. GTM CHECK ============
+    // ============ 9. GTM CHECK ============
     console.log(chalk.blue('🏷️ Đang kiểm tra Google Tag Manager...'));
     try {
       const gtmResults = await this.checkGTMForReport(directory);
@@ -8425,8 +8095,8 @@ class AccessibilityFixer {
         { header: 'Trạng thái', key: 'status', width: 20 },
         { header: 'Head Script', key: 'head', width: 15 },
         { header: 'Body Noscript', key: 'body', width: 15 },
-        { header: 'Container ID', key: 'containerId', width: 20 },
-        { header: 'Vấn đề', key: 'issues', width: 40 }
+        { header: 'Container ID', key: 'containerId', width: 30 },
+        { header: 'Vấn đề', key: 'issues', width: 50 }
       ];
       
       gtmSheet.getRow(1).eachCell(cell => {
@@ -8456,16 +8126,7 @@ class AccessibilityFixer {
       console.log(chalk.yellow(`  ⚠️ GTM: ${error.message}`));
     }
 
-    // ============ 8. SUMMARY SHEET - Populate data ============
-    summarySheet.columns = [
-      { header: 'Thống kê', key: 'stat', width: 35 },
-      { header: 'Giá trị', key: 'value', width: 20 }
-    ];
-    
-    summarySheet.getRow(1).eachCell(cell => {
-      cell.style = headerStyle;
-    });
-    
+    // ============ FILL SUMMARY DATA ============
     const endTime = Date.now();
     const duration = ((endTime - startTime) / 1000).toFixed(2);
     
@@ -8475,13 +8136,15 @@ class AccessibilityFixer {
       { stat: '⏱️ Thời gian xử lý', value: `${duration} giây` },
       { stat: '', value: '' },
       { stat: '🏷️ Meta Tags được phân tích', value: allResults.meta.filter(r => r.status === 'analyzed').length },
+      { stat: '♿ Accessibility Issues (Alt & Aria)', value: allResults.accessibility.length },
+      { stat: '📋 Form Issues', value: allResults.forms.length },
+      { stat: '🔘 Button Issues', value: allResults.buttons.length },
       { stat: '📑 Heading được phân tích', value: allResults.headings.length },
-      { stat: '🔗 Broken Links', value: allResults.brokenLinks.length },
+      { stat: '🔗 Broken External Links', value: allResults.brokenLinks.length },
       { stat: '📁 Missing Resources (404)', value: allResults.missingResources.length },
       { stat: '📁 Unused Files', value: allResults.unusedFiles.length },
-      { stat: '💀 Dead Code', value: allResults.deadCode.length },
-      { stat: '📦 Large Files', value: allResults.fileSize.length },
-      { stat: '🏷️ GTM Files', value: allResults.gtm.length },
+      { stat: '📦 Large Files (>1MB)', value: allResults.fileSize.length },
+      { stat: '🏷️ GTM Issues', value: allResults.gtm.length },
       { stat: '', value: '' },
       { stat: '❌ Tổng số lỗi (Errors)', value: allResults.summary.totalIssues },
       { stat: '⚠️ Tổng số cảnh báo (Warnings)', value: allResults.summary.totalWarnings },
@@ -8544,6 +8207,337 @@ class AccessibilityFixer {
     return results;
   }
 
+  analyzeMetaTags(content, filePath) {
+    const relativePath = path.relative(process.cwd(), filePath);
+    
+    // Skip include files (SSI, partials)
+    const isIncludeFile = /(?:include|partial|component|ssi|header|footer|nav|sidebar)/i.test(relativePath);
+    
+    if (isIncludeFile) {
+      return { isIncludeFile: true, errors: [], fixable: [] };
+    }
+    
+    const errors = []; // Lỗi cần sửa
+    const fixable = []; // Các lỗi có thể tự động sửa
+    
+    // Dictionary of common typos and corrections
+    const propertyTypos = {
+      // Open Graph typos
+      'og:titel': 'og:title',
+      'og:tittle': 'og:title',
+      'og:tilte': 'og:title',
+      'og:discription': 'og:description',
+      'og:descripion': 'og:description',
+      'og:desciption': 'og:description',
+      'og:imge': 'og:image',
+      'og:iamge': 'og:image',
+      'og:typ': 'og:type',
+      'og:tipe': 'og:type',
+      'og:sit_name': 'og:site_name',
+      'og:sitename': 'og:site_name',
+      'og:local': 'og:locale',
+      
+      // Twitter typos
+      'twitter:car': 'twitter:card',
+      'twitter:titel': 'twitter:title',
+      'twitter:tittle': 'twitter:title',
+      'twitter:discription': 'twitter:description',
+      'twitter:descripion': 'twitter:description',
+      'twitter:imge': 'twitter:image',
+      'twitter:iamge': 'twitter:image',
+      'twitter:sit': 'twitter:site',
+      'twitter:creater': 'twitter:creator',
+      
+      // Description typos
+      'discription': 'description',
+      'descripion': 'description',
+      'desciption': 'description',
+      
+      // Viewport typos
+      'viewpor': 'viewport',
+      'veiwport': 'viewport',
+      
+      // Keywords typos
+      'keyword': 'keywords',
+      'keywrods': 'keywords',
+      'keyowrds': 'keywords',
+      
+      // Author typos
+      'auther': 'author',
+      'autor': 'author'
+    };
+    
+    const contentTypos = {
+      // Common og:type values
+      'websit': 'website',
+      'web-site': 'website',
+      'artical': 'article',
+      'aticle': 'article',
+      
+      // Twitter card types
+      'summary_larg_image': 'summary_large_image',
+      'summary-large-image': 'summary_large_image',
+      'summay': 'summary',
+      
+      // Locale typos
+      'ja_jp': 'ja_JP',
+      'en_us': 'en_US',
+      'en-us': 'en_US',
+      'vi_vn': 'vi_VN'
+    };
+    
+    // Extract all meta tags with their full content
+    const metaPattern = /<meta\s+([^>]+)>/gi;
+    const metaTags = [];
+    let match;
+    
+    while ((match = metaPattern.exec(content)) !== null) {
+      const fullTag = match[0];
+      const attrs = match[1];
+      const nameMatch = attrs.match(/(?:name|property)\s*=\s*["']([^"']+)["']/i);
+      const contentMatch = attrs.match(/content\s*=\s*["']([^"']*)["']/i);
+      
+      if (nameMatch) {
+        metaTags.push({
+          fullTag,
+          property: nameMatch[1],
+          content: contentMatch ? contentMatch[1] : '',
+          position: match.index
+        });
+      }
+    }
+    
+    // Check for typos in property names
+    for (const tag of metaTags) {
+      const property = tag.property;
+      const content = tag.content;
+      
+      // Check property typo
+      if (propertyTypos[property.toLowerCase()]) {
+        const correct = propertyTypos[property.toLowerCase()];
+        errors.push(`Lỗi chính tả property: "${property}" → "${correct}"`);
+        fixable.push({
+          type: 'property',
+          wrong: property,
+          correct: correct,
+          fullTag: tag.fullTag
+        });
+      }
+      
+      // Check content typo for specific properties
+      const normalizedProperty = propertyTypos[property.toLowerCase()] || property;
+      
+      if (normalizedProperty === 'og:type') {
+        if (contentTypos[content.toLowerCase()]) {
+          const correct = contentTypos[content.toLowerCase()];
+          errors.push(`Lỗi giá trị og:type: "${content}" → "${correct}"`);
+          fixable.push({
+            type: 'content',
+            property: property,
+            wrong: content,
+            correct: correct,
+            fullTag: tag.fullTag
+          });
+        }
+      }
+      
+      if (normalizedProperty === 'twitter:card') {
+        if (contentTypos[content.toLowerCase()]) {
+          const correct = contentTypos[content.toLowerCase()];
+          errors.push(`Lỗi giá trị twitter:card: "${content}" → "${correct}"`);
+          fixable.push({
+            type: 'content',
+            property: property,
+            wrong: content,
+            correct: correct,
+            fullTag: tag.fullTag
+          });
+        }
+      }
+      
+      if (normalizedProperty === 'og:locale') {
+        // Check exact match first, then lowercase
+        if (contentTypos[content]) {
+          const correct = contentTypos[content];
+          errors.push(`Lỗi giá trị og:locale: "${content}" → "${correct}"`);
+          fixable.push({
+            type: 'content',
+            property: property,
+            wrong: content,
+            correct: correct,
+            fullTag: tag.fullTag
+          });
+        } else if (contentTypos[content.toLowerCase()] && content !== contentTypos[content.toLowerCase()]) {
+          const correct = contentTypos[content.toLowerCase()];
+          errors.push(`Lỗi giá trị og:locale: "${content}" → "${correct}"`);
+          fixable.push({
+            type: 'content',
+            property: property,
+            wrong: content,
+            correct: correct,
+            fullTag: tag.fullTag
+          });
+        }
+      }
+      
+      // Check for syntax errors
+      // 1. Missing content attribute
+      if (!content && !property.startsWith('charset')) {
+        errors.push(`Meta tag "${property}" thiếu thuộc tính content`);
+      }
+      
+      // 2. Empty content
+      if (content === '' && ['og:title', 'og:description', 'twitter:title', 'twitter:description', 'description'].includes(property)) {
+        errors.push(`Meta tag "${property}" có content rỗng`);
+      }
+      
+      // 3. Wrong quotes (mixed single/double)
+      if (tag.fullTag.match(/name=['"]/) && tag.fullTag.match(/content=["'][^"']*['"]/) && 
+          ((tag.fullTag.includes('name="') && tag.fullTag.includes("content='")) ||
+           (tag.fullTag.includes("name='") && tag.fullTag.includes('content="')))) {
+        errors.push(`Meta tag "${property}" sử dụng lẫn lộn dấu ngoặc đơn/kép`);
+      }
+    }
+    
+    return {
+      isIncludeFile: false,
+      errors,
+      fixable,
+      metaTags,
+      hasErrors: errors.length > 0
+    };
+  }
+
+  async checkAccessibilityForReport(directory) {
+    const htmlFiles = await this.findHtmlFiles(directory);
+    const results = [];
+    
+    for (const file of htmlFiles) {
+      try {
+        const content = await fs.readFile(file, 'utf8');
+        const issues = [];
+        
+        // 1. Check Images (Alt text)
+        const imgPattern = /<img\s+[^>]*>/gi;
+        let match;
+        while ((match = imgPattern.exec(content)) !== null) {
+          const imgTag = match[0];
+          const altMatch = imgTag.match(/alt=["']([^"']*)["']/i);
+          
+          if (!altMatch) {
+            issues.push({ type: 'Missing Alt', description: 'Thẻ img thiếu thuộc tính alt', element: imgTag });
+          } else if (altMatch[1].trim() === '') {
+            // Empty alt is ONLY okay for decorative images with role="presentation" or aria-hidden="true"
+            const isDecorative = imgTag.includes('role="presentation"') || imgTag.includes('aria-hidden="true"');
+            if (!isDecorative) {
+              issues.push({ type: 'Empty Alt', description: 'Alt text bị bỏ trống (không phải ảnh trang trí)', element: imgTag });
+            }
+          }
+        }
+
+        // 2. Check Aria Labels - always report empty aria-label as error
+        const ariaPattern = /<([a-z][a-z0-9]*)\s+[^>]*aria-label=["']([^"']*)["'][^>]*>/gi;
+        while ((match = ariaPattern.exec(content)) !== null) {
+          const ariaValue = match[2].trim();
+          if (ariaValue === '') {
+            issues.push({ type: 'Empty Aria-Label', description: 'Thuộc tính aria-label bị bỏ trống', element: `<${match[1]} aria-label=""...>` });
+          }
+        }
+
+        if (issues.length > 0) {
+          results.push({ file, issues });
+        }
+      } catch (error) {
+        // Skip
+      }
+    }
+    return results;
+  }
+
+  async checkFormsForReport(directory) {
+    const htmlFiles = await this.findHtmlFiles(directory);
+    const results = [];
+    
+    for (const file of htmlFiles) {
+      try {
+        const content = await fs.readFile(file, 'utf8');
+        const issues = [];
+        
+        // Check Forms (Labels)
+        const inputPattern = /<input\s+[^>]*>/gi;
+        let match;
+        while ((match = inputPattern.exec(content)) !== null) {
+          const inputTag = match[0];
+          const typeMatch = inputTag.match(/type=["']([^"']*)["']/i);
+          const type = typeMatch ? typeMatch[1].toLowerCase() : 'text';
+          
+          if (['text', 'password', 'email', 'search', 'tel', 'url', 'number', 'date'].includes(type)) {
+            const hasId = inputTag.match(/id=["']([^"']*)["']/i);
+            const hasAriaLabel = inputTag.includes('aria-label');
+            const hasAriaLabelledBy = inputTag.includes('aria-labelledby');
+            
+            if (!hasAriaLabel && !hasAriaLabelledBy) {
+              let hasLabel = false;
+              if (hasId) {
+                const id = hasId[1];
+                const labelPattern = new RegExp(`<label\\s+[^>]*for=["']${id}["']`, 'i');
+                if (labelPattern.test(content)) {
+                  hasLabel = true;
+                }
+              }
+              
+              if (!hasLabel) {
+                issues.push({ type: 'Missing Form Label', description: `Input type="${type}" thiếu label hoặc aria-label`, element: inputTag });
+              }
+            }
+          }
+        }
+
+        if (issues.length > 0) {
+          results.push({ file, issues });
+        }
+      } catch (error) {
+        // Skip
+      }
+    }
+    return results;
+  }
+
+  async checkButtonsForReport(directory) {
+    const htmlFiles = await this.findHtmlFiles(directory);
+    const results = [];
+    
+    for (const file of htmlFiles) {
+      try {
+        const content = await fs.readFile(file, 'utf8');
+        const issues = [];
+        
+        // Check Buttons (Name/Content)
+        const buttonPattern = /<button\s*([^>]*)>([\s\S]*?)<\/button>/gi;
+        let match;
+        while ((match = buttonPattern.exec(content)) !== null) {
+          const attrs = match[1];
+          const innerContent = match[2].trim();
+          const hasAriaLabel = attrs.includes('aria-label');
+          const hasAriaLabelledBy = attrs.includes('aria-labelledby');
+          
+          if (innerContent === '' && !hasAriaLabel && !hasAriaLabelledBy) {
+            if (!innerContent.match(/<img\s+[^>]*alt=["'][^"']+["']/i)) {
+              issues.push({ type: 'Empty Button', description: 'Button rỗng không có text hoặc aria-label', element: `<button ${attrs}>...` });
+            }
+          }
+        }
+
+        if (issues.length > 0) {
+          results.push({ file, issues });
+        }
+      } catch (error) {
+        // Skip
+      }
+    }
+    return results;
+  }
+
   async analyzeHeadingsForReport(directory) {
     const htmlFiles = await this.findHtmlFiles(directory);
     const results = [];
@@ -8616,52 +8610,97 @@ class AccessibilityFixer {
   }
 
   async checkBrokenLinksForReport(directory) {
-    return { brokenLinks: [], missingResources: [] };
-    // Simplified - actual implementation would check links
+    const htmlFiles = await this.findHtmlFiles(directory);
+    const missingResources = [];
+    
+    for (const file of htmlFiles) {
+      try {
+        const content = await fs.readFile(file, 'utf8');
+        const fileDir = path.dirname(file);
+        
+        // Check src attributes (images, scripts)
+        const srcPattern = /src=["']([^"']+)["']/gi;
+        let match;
+        while ((match = srcPattern.exec(content)) !== null) {
+          const src = match[1];
+          // Skip external links, data URIs, and template variables
+          if (src.startsWith('http') || src.startsWith('//') || src.startsWith('data:') || src.includes('{{') || src.includes('<%')) continue;
+          
+          const cleanSrc = src.split('?')[0].split('#')[0];
+          // Handle absolute paths (starting with /) - resolve from project root
+          const absolutePath = cleanSrc.startsWith('/') 
+            ? path.join(directory, cleanSrc)
+            : path.resolve(fileDir, cleanSrc);
+          
+          try {
+            await fs.access(absolutePath);
+          } catch {
+            missingResources.push({
+              source: path.relative(directory, file),
+              path: src,
+              type: 'Missing Resource'
+            });
+          }
+        }
+        
+        // Check href attributes (css, links) - only check local files
+        const hrefPattern = /href=["']([^"']+)["']/gi;
+        while ((match = hrefPattern.exec(content)) !== null) {
+          const href = match[1];
+          // Skip external, anchors, javascript, mailto, tel
+          if (href.startsWith('http') || href.startsWith('//') || href.startsWith('#') || href.startsWith('javascript:') || href.startsWith('mailto:') || href.startsWith('tel:')) continue;
+          
+          const cleanHref = href.split('?')[0].split('#')[0];
+          // Handle absolute paths (starting with /) - resolve from project root
+          const absolutePath = cleanHref.startsWith('/') 
+            ? path.join(directory, cleanHref)
+            : path.resolve(fileDir, cleanHref);
+          
+          try {
+            await fs.access(absolutePath);
+          } catch {
+            missingResources.push({
+              source: path.relative(directory, file),
+              path: href,
+              type: 'Broken Local Link'
+            });
+          }
+        }
+      } catch (error) {
+        // Skip
+      }
+    }
+    
+    return { brokenLinks: [], missingResources };
   }
 
   async checkUnusedFilesForReport(directory) {
-    return [];
-    // Simplified - actual implementation would check unused files
-  }
-
-  async checkDeadCodeForReport(directory) {
-    return [];
-    // Simplified - actual implementation would check dead code
+    // Use the same logic as checkUnusedFiles for consistency
+    const result = await this.checkUnusedFiles(directory, { returnDetails: true });
+    return result.unusedFiles || [];
   }
 
   async checkFileSizeForReport(directory) {
     const results = [];
-    const thresholds = {
-      '.jpg': 200 * 1024,
-      '.jpeg': 200 * 1024,
-      '.png': 200 * 1024,
-      '.gif': 500 * 1024,
-      '.svg': 50 * 1024,
-      '.css': 100 * 1024,
-      '.js': 200 * 1024,
-      '.html': 100 * 1024
-    };
+    const ONE_MB = 1024 * 1024;
     
     try {
       const files = await this.findAllFiles(directory);
       for (const file of files) {
         try {
           const stats = await fs.stat(file);
-          const ext = path.extname(file).toLowerCase();
-          const threshold = thresholds[ext];
-          
-          if (threshold && stats.size > threshold) {
+          if (stats.size > ONE_MB) {
+            const ext = path.extname(file).toLowerCase();
             results.push({
               file: path.relative(directory, file),
               type: ext.slice(1).toUpperCase(),
               size: stats.size,
-              threshold: threshold,
+              threshold: ONE_MB,
               suggestion: this.getFileSizeSuggestion(ext)
             });
           }
         } catch (e) {
-          // Skip files that can't be read
+          // Skip
         }
       }
     } catch (error) {
@@ -8680,9 +8719,11 @@ class AccessibilityFixer {
       '.svg': 'Tối ưu SVG với SVGO',
       '.css': 'Minify CSS và loại bỏ code không dùng',
       '.js': 'Minify JS, tree-shaking và code splitting',
-      '.html': 'Minify HTML và loại bỏ comments'
+      '.html': 'Minify HTML và loại bỏ comments',
+      '.mp4': 'Nén video hoặc dùng dịch vụ streaming',
+      '.pdf': 'Nén PDF'
     };
-    return suggestions[ext] || 'Cân nhắc tối ưu hóa file';
+    return suggestions[ext] || 'File > 1MB. Cân nhắc tối ưu hóa hoặc lazy loading.';
   }
 
   async checkGTMForReport(directory) {
@@ -8693,34 +8734,55 @@ class AccessibilityFixer {
       try {
         const content = await fs.readFile(file, 'utf8');
         
-        // Check for DOCTYPE (skip partials)
         if (!/<html/i.test(content)) continue;
         
-        const gtmHeadPattern = /<!--\s*Google Tag Manager\s*-->[\s\S]*?<script[\s\S]*?gtm\.js[\s\S]*?<\/script>[\s\S]*?<!--\s*End Google Tag Manager\s*-->/i;
-        const gtmBodyPattern = /<!--\s*Google Tag Manager \(noscript\)\s*-->[\s\S]*?<noscript>[\s\S]*?googletagmanager\.com[\s\S]*?<\/noscript>[\s\S]*?<!--\s*End Google Tag Manager \(noscript\)\s*-->/i;
-        const gtmIdPattern = /GTM-[A-Z0-9]+/i;
+        // Find all GTM IDs
+        const gtmIdPattern = /GTM-[A-Z0-9]+/g;
+        const matches = content.match(gtmIdPattern) || [];
+        const uniqueIds = [...new Set(matches)];
+        
+        // Count GTM head scripts
+        const gtmHeadPattern = /<script[\s\S]*?gtm\.js[\s\S]*?<\/script>/gi;
+        const headScripts = content.match(gtmHeadPattern) || [];
+        const headScriptCount = headScripts.filter(script => script.includes('googletagmanager.com/gtm.js')).length;
+        
+        // Count GTM body noscripts
+        const gtmBodyPattern = /<noscript>[\s\S]*?googletagmanager\.com\/ns\.html[\s\S]*?<\/noscript>/gi;
+        const bodyNoscripts = content.match(gtmBodyPattern) || [];
+        const bodyNoscriptCount = bodyNoscripts.length;
         
-        const hasHeadScript = gtmHeadPattern.test(content);
-        const hasBodyNoscript = gtmBodyPattern.test(content);
-        const containerId = content.match(gtmIdPattern)?.[0] || null;
-        const hasGTM = hasHeadScript || hasBodyNoscript;
+        const hasGTM = uniqueIds.length > 0;
+        const hasHeadScript = headScriptCount > 0;
+        const hasBodyNoscript = bodyNoscriptCount > 0;
         
         const issues = [];
-        if (hasHeadScript && !hasBodyNoscript) {
-          issues.push('Thiếu noscript trong body');
-        }
-        if (!hasHeadScript && hasBodyNoscript) {
-          issues.push('Thiếu script trong head');
+        
+        // Check for missing or mismatched parts
+        if (hasGTM) {
+          if (!hasHeadScript) {
+            issues.push('Thiếu GTM script trong <head>');
+          } else if (headScriptCount !== uniqueIds.length) {
+            issues.push(`Số lượng GTM script trong <head> (${headScriptCount}) không khớp với số GTM ID (${uniqueIds.length})`);
+          }
+          
+          if (!hasBodyNoscript) {
+            issues.push('Thiếu GTM noscript trong <body>');
+          } else if (bodyNoscriptCount !== uniqueIds.length) {
+            issues.push(`Số lượng GTM noscript trong <body> (${bodyNoscriptCount}) không khớp với số GTM ID (${uniqueIds.length})`);
+          }
         }
         
-        results.push({
-          file: path.relative(directory, file),
-          hasGTM,
-          hasHeadScript,
-          hasBodyNoscript,
-          containerId,
-          issues
-        });
+        // Only add to results if there's an issue or no GTM
+        if (!hasGTM || issues.length > 0) {
+          results.push({
+            file: path.relative(directory, file),
+            hasGTM,
+            hasHeadScript,
+            hasBodyNoscript,
+            containerId: uniqueIds.length > 0 ? `${uniqueIds.join(', ')} (${uniqueIds.length} GTM)` : '-',
+            issues
+          });
+        }
       } catch (error) {
         // Skip files with errors
       }
@@ -8751,12 +8813,6 @@ class AccessibilityFixer {
     await walk(directory);
     return files;
   }
-
-  formatFileSize(bytes) {
-    if (bytes < 1024) return bytes + ' B';
-    if (bytes < 1024 * 1024) return (bytes / 1024).toFixed(1) + ' KB';
-    return (bytes / (1024 * 1024)).toFixed(2) + ' MB';
-  }
 }
 
-module.exports = AccessibilityFixer;
+module.exports = AccessibilityFixer;