gbu-accessibility-package 3.12.0 → 3.13.0

package/lib/fixer.js

@@ -1229,18 +1229,22 @@ class EnhancedAltChecker {
 class AccessibilityFixer {
   constructor(config = {}) {
     this.config = {
-      backupFiles: config.backupFiles === true,
+      backupFiles: false,
       language: config.language || 'ja',
-      dryRun: config.dryRun || false,
+      dryRun: true,
       enhancedAltMode: config.enhancedAltMode || false,
       altCreativity: config.altCreativity || 'balanced', // conservative, balanced, creative
       includeEmotions: config.includeEmotions || false,
       strictAltChecking: config.strictAltChecking || false,
-      // New options for advanced features
-      autoFixHeadings: config.autoFixHeadings || false, // Enable automatic heading fixes
-      fixDescriptionLists: config.fixDescriptionLists || true, // Enable DL structure fixes
+      autoFixHeadings: false,
+      fixDescriptionLists: config.fixDescriptionLists !== false,
+      checkOnlyMode: true,
       ...config
     };
+    this.config.backupFiles = false;
+    this.config.dryRun = true;
+    this.config.autoFixHeadings = false;
+    this.config.checkOnlyMode = true;
     
     // Initialize enhanced alt tools
     this.enhancedAltChecker = new EnhancedAltChecker({
@@ -5886,108 +5890,8 @@ class AccessibilityFixer {
 
   // 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.'));
-    }
+    console.log(chalk.yellow('⚠️ Check-only mode: auto-fixing meta tags has been removed. Running analysis only.'));
+    return this.checkMetaTags(directory, options);
   }
 
   // Check for unused files in the project - enhanced for comprehensive project-wide scanning
@@ -6073,6 +5977,130 @@ 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 = true;
+    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;
+        }
+
+        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
@@ -6310,12 +6338,17 @@ class AccessibilityFixer {
             const srcUrl = parts[0];
             
             if (srcUrl) {
+              const normalizedSrcUrl = this.normalizeReferenceUrl(srcUrl);
+              if (!normalizedSrcUrl) {
+                return;
+              }
+
               // Check if it's a local file
-              if (this.isLocalFile(srcUrl)) {
-                this.addNormalizedUrl(references, srcUrl);
-              } else if (this.isAbsoluteUrlToLocalFile(srcUrl)) {
+              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(srcUrl);
+                const localPath = this.extractLocalPathFromAbsoluteUrl(normalizedSrcUrl);
                 if (localPath) {
                   this.addNormalizedUrl(references, localPath);
                 }
@@ -6323,12 +6356,17 @@ class AccessibilityFixer {
             }
           });
         } else {
+          const normalizedUrl = this.normalizeReferenceUrl(url);
+          if (!normalizedUrl) {
+            continue;
+          }
+
           // Regular src/href/content attributes
-          if (this.isLocalFile(url)) {
-            this.addNormalizedUrl(references, url);
-          } else if (this.isAbsoluteUrlToLocalFile(url)) {
+          if (this.isLocalFile(normalizedUrl)) {
+            this.addNormalizedUrl(references, normalizedUrl);
+          } else if (this.isAbsoluteUrlToLocalFile(normalizedUrl)) {
             // Extract local path from absolute URL
-            const localPath = this.extractLocalPathFromAbsoluteUrl(url);
+            const localPath = this.extractLocalPathFromAbsoluteUrl(normalizedUrl);
             if (localPath) {
               this.addNormalizedUrl(references, localPath);
             }
@@ -6342,43 +6380,75 @@ class AccessibilityFixer {
 
   // Check if URL is an absolute URL that points to a local file (same domain or project assets)
   isAbsoluteUrlToLocalFile(url) {
-    if (!url.startsWith('http://') && !url.startsWith('https://')) {
+    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 url.includes('/assets/') || 
-           url.includes('/static/') || 
-           url.includes('/img/') ||
-           url.includes('/images/') ||
-           url.includes('/css/') ||
-           url.includes('/js/') ||
-           url.includes('/media/') ||
-           url.includes('/fonts/') ||
-           url.match(/\.(jpg|jpeg|png|gif|svg|webp|css|js|ico|pdf|mp4|webm)$/i);
+    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 urlObj = new URL(url);
+      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 ./
     }
   }
 
@@ -6398,7 +6468,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);
         }
@@ -6424,15 +6494,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);
         }
@@ -6532,7 +6602,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);
         }
@@ -6564,7 +6634,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);
         }
@@ -6698,13 +6768,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) {
@@ -7378,9 +7453,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);
             }
@@ -7419,7 +7499,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);
@@ -7624,6 +7704,7 @@ class AccessibilityFixer {
         { header: 'Loại lỗi', key: 'type', width: 20 },
         { header: 'Mô tả', key: 'description', width: 60 },
         { header: 'Element', key: 'element', width: 40 },
+        { header: 'Gợi ý xử lý', key: 'suggestion', width: 50 },
         { header: 'Mức độ', key: 'severity', width: 15 }
       ];
       
@@ -7639,6 +7720,7 @@ class AccessibilityFixer {
             type: issue.type,
             description: issue.description,
             element: issue.element || '',
+            suggestion: this.getAccessibilitySuggestion(issue),
             severity: '❌ Lỗi'
           });
           row.getCell('severity').style = errorStyle;
@@ -7646,7 +7728,7 @@ class AccessibilityFixer {
         }
       }
       
-      accessSheet.autoFilter = 'A1:E1';
+      accessSheet.autoFilter = 'A1:F1';
       console.log(chalk.green(`  ✅ Accessibility: ${accessResults.length} file có vấn đề`));
     } catch (error) {
       console.log(chalk.yellow(`  ⚠️ Accessibility: ${error.message}`));
@@ -7664,6 +7746,7 @@ class AccessibilityFixer {
         { header: 'Loại lỗi', key: 'type', width: 25 },
         { header: 'Mô tả', key: 'description', width: 60 },
         { header: 'Element', key: 'element', width: 40 },
+        { header: 'Gợi ý xử lý', key: 'suggestion', width: 50 },
         { header: 'Mức độ', key: 'severity', width: 15 }
       ];
       
@@ -7679,6 +7762,7 @@ class AccessibilityFixer {
             type: issue.type,
             description: issue.description,
             element: issue.element || '',
+            suggestion: this.getFormSuggestion(issue),
             severity: '❌ Lỗi'
           });
           row.getCell('severity').style = errorStyle;
@@ -7686,7 +7770,7 @@ class AccessibilityFixer {
         }
       }
       
-      formsSheet.autoFilter = 'A1:E1';
+      formsSheet.autoFilter = 'A1:F1';
       console.log(chalk.green(`  ✅ Forms: ${formsResults.length} file có vấn đề`));
     } catch (error) {
       console.log(chalk.yellow(`  ⚠️ Forms: ${error.message}`));
@@ -7704,6 +7788,7 @@ class AccessibilityFixer {
         { header: 'Loại lỗi', key: 'type', width: 25 },
         { header: 'Mô tả', key: 'description', width: 60 },
         { header: 'Element', key: 'element', width: 40 },
+        { header: 'Gợi ý xử lý', key: 'suggestion', width: 50 },
         { header: 'Mức độ', key: 'severity', width: 15 }
       ];
       
@@ -7719,6 +7804,7 @@ class AccessibilityFixer {
             type: issue.type,
             description: issue.description,
             element: issue.element || '',
+            suggestion: this.getButtonSuggestion(issue),
             severity: '❌ Lỗi'
           });
           row.getCell('severity').style = errorStyle;
@@ -7726,7 +7812,7 @@ class AccessibilityFixer {
         }
       }
       
-      buttonsSheet.autoFilter = 'A1:E1';
+      buttonsSheet.autoFilter = 'A1:F1';
       console.log(chalk.green(`  ✅ Buttons: ${buttonsResults.length} file có vấn đề`));
     } catch (error) {
       console.log(chalk.yellow(`  ⚠️ Buttons: ${error.message}`));
@@ -7790,7 +7876,8 @@ class AccessibilityFixer {
         { header: 'URL/Đường dẫn', key: 'url', width: 60 },
         { header: 'Loại', key: 'type', width: 20 },
         { header: 'Trạng thái', key: 'status', width: 15 },
-        { header: 'Mô tả', key: 'description', width: 40 }
+        { header: 'Mô tả', key: 'description', width: 40 },
+        { header: 'Gợi ý xử lý', key: 'suggestion', width: 50 }
       ];
       
       linksSheet.getRow(1).eachCell(cell => {
@@ -7803,7 +7890,8 @@ class AccessibilityFixer {
           url: link.url,
           type: 'External Link',
           status: link.status || 'Broken',
-          description: link.error || 'Link không thể truy cập'
+          description: link.error || 'Link không thể truy cập',
+          suggestion: link.suggestion || this.getLinkReportSuggestion(link, 'external')
         });
         row.getCell('status').style = errorStyle;
         allResults.summary.totalIssues++;
@@ -7815,13 +7903,14 @@ class AccessibilityFixer {
           url: resource.path,
           type: 'Local Resource',
           status: '404',
-          description: 'File không tồn tại'
+          description: 'File không tồn tại',
+          suggestion: resource.suggestion || this.getLinkReportSuggestion(resource, 'local')
         });
         row.getCell('status').style = errorStyle;
         allResults.summary.totalIssues++;
       }
       
-      linksSheet.autoFilter = 'A1:E1';
+      linksSheet.autoFilter = 'A1:F1';
       console.log(chalk.green(`  ✅ Broken Links: ${allResults.brokenLinks.length} link, ${allResults.missingResources.length} resource`));
     } catch (error) {
       console.log(chalk.yellow(`  ⚠️ Broken Links: ${error.message}`));
@@ -7838,7 +7927,8 @@ class AccessibilityFixer {
         { header: 'File', key: 'file', width: 60 },
         { header: 'Loại', key: 'type', width: 20 },
         { header: 'Kích thước', key: 'size', width: 15 },
-        { header: 'Ghi chú', key: 'note', width: 40 }
+        { header: 'Ghi chú', key: 'note', width: 40 },
+        { header: 'Gợi ý xử lý', key: 'suggestion', width: 50 }
       ];
       
       unusedSheet.getRow(1).eachCell(cell => {
@@ -7854,13 +7944,14 @@ class AccessibilityFixer {
           file: filePath,
           type: fileType,
           size: fileSize,
-          note: 'Không được tham chiếu trong project'
+          note: 'Không được tham chiếu trong project',
+          suggestion: typeof file === 'object' ? (file.suggestion || 'Xác minh file có đang được dùng động không; nếu không cần, xóa thủ công khỏi project.') : 'Xác minh file có đang được dùng động không; nếu không cần, xóa thủ công khỏi project.'
         });
         row.getCell('note').style = warningStyle;
         allResults.summary.totalWarnings++;
       }
       
-      unusedSheet.autoFilter = 'A1:D1';
+      unusedSheet.autoFilter = 'A1:E1';
       console.log(chalk.green(`  ✅ Unused Files: ${unusedResults.length} file`));
     } catch (error) {
       console.log(chalk.yellow(`  ⚠️ Unused Files: ${error.message}`));
@@ -7916,7 +8007,8 @@ class AccessibilityFixer {
         { header: 'Head Script', key: 'head', width: 15 },
         { header: 'Body Noscript', key: 'body', width: 15 },
         { header: 'Container ID', key: 'containerId', width: 30 },
-        { header: 'Vấn đề', key: 'issues', width: 50 }
+        { header: 'Vấn đề', key: 'issues', width: 50 },
+        { header: 'Gợi ý xử lý', key: 'suggestion', width: 50 }
       ];
       
       gtmSheet.getRow(1).eachCell(cell => {
@@ -7930,7 +8022,8 @@ class AccessibilityFixer {
           head: item.hasHeadScript ? '✅' : '❌',
           body: item.hasBodyNoscript ? '✅' : '❌',
           containerId: item.containerId || '-',
-          issues: (item.issues || []).join('; ') || 'Không có vấn đề'
+          issues: (item.issues || []).join('; ') || 'Không có vấn đề',
+          suggestion: this.getGTMReportSuggestion(item)
         });
         if (!item.hasGTM || item.issues?.length > 0) {
           row.getCell('status').style = errorStyle;
@@ -7940,7 +8033,7 @@ class AccessibilityFixer {
         }
       }
       
-      gtmSheet.autoFilter = 'A1:F1';
+      gtmSheet.autoFilter = 'A1:G1';
       console.log(chalk.green(`  ✅ GTM: ${gtmResults.length} file`));
     } catch (error) {
       console.log(chalk.yellow(`  ⚠️ GTM: ${error.message}`));
@@ -8010,6 +8103,77 @@ class AccessibilityFixer {
   }
 
   // Helper methods for report generation
+  getAccessibilitySuggestion(issue = {}) {
+    const type = (issue.type || '').toLowerCase();
+
+    if (type.includes('missing alt')) {
+      return 'Thêm thuộc tính alt mô tả đúng nội dung/chức năng của ảnh; nếu ảnh chỉ để trang trí, dùng alt="" và cân nhắc role="presentation".';
+    }
+
+    if (type.includes('empty alt')) {
+      return 'Điền alt text có ý nghĩa cho ảnh, hoặc nếu ảnh thực sự chỉ để trang trí thì giữ alt="" và đánh dấu rõ là decorative.';
+    }
+
+    if (type.includes('empty aria-label')) {
+      return 'Điền aria-label ngắn gọn nhưng đủ nghĩa, hoặc thay bằng text hiển thị/aria-labelledby nếu phần tử đã có nội dung liên kết rõ ràng.';
+    }
+
+    return 'Xem lại accessible name và semantic của phần tử, rồi cập nhật text thay thế hoặc ARIA cho phù hợp với chức năng thực tế.';
+  }
+
+  getFormSuggestion(issue = {}) {
+    const type = (issue.type || '').toLowerCase();
+
+    if (type.includes('missing form label')) {
+      return 'Thêm <label for="..."> liên kết với input, hoặc bổ sung aria-label/aria-labelledby nếu không thể dùng label hiển thị.';
+    }
+
+    return 'Đảm bảo mỗi trường nhập liệu có accessible name rõ ràng và không phụ thuộc riêng vào placeholder.';
+  }
+
+  getButtonSuggestion(issue = {}) {
+    const type = (issue.type || '').toLowerCase();
+
+    if (type.includes('empty button')) {
+      return 'Thêm text hiển thị cho button, hoặc bổ sung aria-label nếu button chỉ chứa icon nhưng vẫn cần tên truy cập được.';
+    }
+
+    return 'Đảm bảo button có accessible name rõ ràng, ngắn gọn, và phản ánh đúng hành động của nó.';
+  }
+
+  getLinkReportSuggestion(item = {}, mode = 'external') {
+    if (item.suggestion) {
+      return item.suggestion;
+    }
+
+    if (mode === 'local') {
+      return 'Kiểm tra lại path tham chiếu, tạo file còn thiếu, hoặc cập nhật/xóa reference không còn dùng.';
+    }
+
+    return 'Kiểm tra lại URL đích, cập nhật link mới nếu trang đã đổi, hoặc gỡ liên kết nếu tài nguyên không còn tồn tại.';
+  }
+
+  getGTMReportSuggestion(item = {}) {
+    if (!item.hasGTM) {
+      return 'Thêm đầy đủ GTM script trong <head> và GTM noscript ngay sau thẻ mở <body> nếu trang này cần được tracking.';
+    }
+
+    const suggestions = [];
+    const issues = item.issues || [];
+
+    for (const issue of issues) {
+      if (issue.includes('Thiếu GTM script')) {
+        suggestions.push('Bổ sung GTM script vào <head>, ưu tiên đặt ngay trước </head>.');
+      } else if (issue.includes('Thiếu GTM noscript')) {
+        suggestions.push('Bổ sung GTM noscript ngay sau thẻ mở <body>.');
+      } else if (issue.includes('không khớp')) {
+        suggestions.push('Đồng bộ số lượng script/noscript với các container ID GTM đang dùng trên trang.');
+      }
+    }
+
+    return suggestions.join(' ') || 'Xác minh lại cấu hình GTM giữa phần head, body noscript, và container ID.';
+  }
+
   async checkMetaTagsForReport(directory) {
     const htmlFiles = await this.findHtmlFiles(directory);
     const results = [];
@@ -8635,4 +8799,4 @@ class AccessibilityFixer {
   }
 }
 
-module.exports = AccessibilityFixer;
+module.exports = AccessibilityFixer;