gbu-accessibility-package 3.8.0 → 3.8.2

package/lib/fixer.js

@@ -1451,6 +1451,136 @@ class AccessibilityFixer {
     return results;
   }
 
+  // Fix aria-labels for images and other elements
+  async fixAriaLabels(directory = '.') {
+    console.log(chalk.blue('🏷️ Fixing aria-label attributes...'));
+    
+    const htmlFiles = await this.findHtmlFiles(directory);
+    const results = [];
+    let totalIssuesFound = 0;
+    
+    for (const file of htmlFiles) {
+      try {
+        const content = await fs.readFile(file, 'utf8');
+        const fixed = this.fixAriaLabelsInContent(content);
+        
+        if (fixed.content !== content) {
+          if (!this.config.dryRun) {
+            if (this.config.backupFiles) {
+              await fs.writeFile(`${file}.backup`, content);
+            }
+            await fs.writeFile(file, fixed.content);
+          }
+          
+          console.log(chalk.green(`✅ Fixed aria-label attributes in: ${file}`));
+          totalIssuesFound += fixed.changes;
+        }
+        
+        results.push({ file, status: 'processed', changes: fixed.changes });
+      } catch (error) {
+        console.error(chalk.red(`❌ Error processing ${file}: ${error.message}`));
+        results.push({ file, status: 'error', error: error.message });
+      }
+    }
+    
+    console.log(chalk.blue(`\n📊 Summary: Found ${totalIssuesFound} aria-label issues across ${results.length} files`));
+    return results;
+  }
+
+  fixAriaLabelsInContent(content) {
+    let fixed = content;
+    let changes = 0;
+    
+    // Fix images - add aria-label from alt text
+    fixed = fixed.replace(
+      /<img([^>]*>)/gi,
+      (match) => {
+        // Check if aria-label already exists
+        if (/aria-label\s*=/i.test(match)) {
+          return match; // Return unchanged if aria-label already exists
+        }
+        
+        // Extract alt text to use for aria-label
+        const altMatch = match.match(/alt\s*=\s*["']([^"']*)["']/i);
+        if (altMatch && altMatch[1].trim()) {
+          const altText = altMatch[1].trim();
+          const updatedImg = match.replace(/(<img[^>]*?)(\s*>)/i, `$1 aria-label="${altText}"$2`);
+          console.log(chalk.yellow(`  🏷️ Added aria-label="${altText}" to image element`));
+          changes++;
+          return updatedImg;
+        }
+        
+        return match;
+      }
+    );
+    
+    // Fix buttons without aria-label but with text content
+    fixed = fixed.replace(
+      /<button([^>]*>)(.*?)<\/button>/gi,
+      (match, attributes, content) => {
+        // Skip if aria-label already exists
+        if (/aria-label\s*=/i.test(attributes)) {
+          return match;
+        }
+        
+        // Extract text content for aria-label
+        const textContent = content.replace(/<[^>]*>/g, '').trim();
+        if (textContent) {
+          const updatedButton = match.replace(/(<button[^>]*?)(\s*>)/i, `$1 aria-label="${textContent}"$2`);
+          console.log(chalk.yellow(`  🏷️ Added aria-label="${textContent}" to button element`));
+          changes++;
+          return updatedButton;
+        }
+        
+        return match;
+      }
+    );
+    
+    // Fix links without aria-label but with text content
+    fixed = fixed.replace(
+      /<a([^>]*href[^>]*>)(.*?)<\/a>/gi,
+      (match, attributes, content) => {
+        // Skip if aria-label already exists
+        if (/aria-label\s*=/i.test(attributes)) {
+          return match;
+        }
+        
+        // Skip if it's just text content (not generic)
+        const textContent = content.replace(/<[^>]*>/g, '').trim();
+        const genericTexts = ['link', 'click here', 'read more', 'more info', 'here', 'this'];
+        
+        if (textContent && genericTexts.some(generic => 
+          textContent.toLowerCase().includes(generic.toLowerCase()))) {
+          // Extract meaningful context or use href for generic links
+          const hrefMatch = attributes.match(/href\s*=\s*["']([^"']*)["']/i);
+          if (hrefMatch && hrefMatch[1]) {
+            const href = hrefMatch[1];
+            let ariaLabel = textContent;
+            
+            // Improve generic link text
+            if (href.includes('mailto:')) {
+              ariaLabel = `Email: ${href.replace('mailto:', '')}`;
+            } else if (href.includes('tel:')) {
+              ariaLabel = `Phone: ${href.replace('tel:', '')}`;
+            } else if (href.startsWith('http')) {
+              const domain = new URL(href).hostname;
+              ariaLabel = `Link to ${domain}`;
+            }
+            
+            const updatedLink = match.replace(/(<a[^>]*?)(\s*>)/i, `$1 aria-label="${ariaLabel}"$2`);
+            console.log(chalk.yellow(`  🏷️ Added aria-label="${ariaLabel}" to link element`));
+            changes++;
+            return updatedLink;
+          }
+        }
+        
+        return match;
+      }
+    );
+    
+    return { content: fixed, changes };
+  }
+
   async addMainLandmarks(directory = '.') {
     console.log(chalk.yellow('🏗️ Main landmark detection (manual review required)...'));
     
@@ -2014,33 +2144,18 @@ class AccessibilityFixer {
     // Fix picture elements with img children - move role from picture to img
     fixed = this.fixPictureImgRoles(fixed);
     
-    // Fix all images - add role="img" and aria-label
+    // Fix all images - add role="img" only
     fixed = fixed.replace(
       /<img([^>]*>)/gi,
       (match) => {
-        let updatedImg = match;
-        let hasChanges = false;
-        
         // Check if role attribute already exists
         if (!/role\s*=/i.test(match)) {
-          updatedImg = updatedImg.replace(/(<img[^>]*?)(\s*>)/i, '$1 role="img"$2');
+          const updatedImg = match.replace(/(<img[^>]*?)(\s*>)/i, '$1 role="img"$2');
           console.log(chalk.yellow(`  🖼️ Added role="img" to image element`));
-          hasChanges = true;
-        }
-        
-        // Check if aria-label already exists
-        if (!/aria-label\s*=/i.test(match)) {
-          // Extract alt text to use for aria-label
-          const altMatch = match.match(/alt\s*=\s*["']([^"']*)["']/i);
-          if (altMatch && altMatch[1].trim()) {
-            const altText = altMatch[1].trim();
-            updatedImg = updatedImg.replace(/(<img[^>]*?)(\s*>)/i, `$1 aria-label="${altText}"$2`);
-            console.log(chalk.yellow(`  🏷️ Added aria-label="${altText}" to image element`));
-            hasChanges = true;
-          }
+          return updatedImg;
         }
         
-        return updatedImg;
+        return match;
       }
     );
     
@@ -3106,13 +3221,14 @@ class AccessibilityFixer {
   async checkLocalFile(url, baseDir, resourceType, elementType) {
     const path = require('path');
     
-    // Handle relative URLs
+    // Handle different URL types
     let filePath;
     if (url.startsWith('/')) {
-      // Absolute path from web root - we'll check relative to baseDir
-      filePath = path.join(baseDir, url.substring(1));
+      // Absolute path from web root - find project root and resolve from there
+      const projectRoot = this.findProjectRoot(baseDir);
+      filePath = path.join(projectRoot, url.substring(1));
     } else {
-      // Relative path
+      // Relative path - resolve relative to current HTML file directory
       filePath = path.resolve(baseDir, url);
     }
     
@@ -3126,11 +3242,41 @@ class AccessibilityFixer {
         suggestion: `Create the missing file or update the ${resourceType.toLowerCase()} path`,
         url: url,
         filePath: filePath,
+        resolvedPath: filePath,
         resourceType: resourceType
       };
     }
   }
 
+  // Helper method to find project root directory
+  findProjectRoot(startDir) {
+    const path = require('path');
+    const fs = require('fs');
+    
+    let currentDir = startDir;
+    const root = path.parse(currentDir).root;
+    
+    // Look for common project root indicators
+    while (currentDir !== root) {
+      // Check for package.json, .git, or other project indicators
+      const packageJsonPath = path.join(currentDir, 'package.json');
+      const gitPath = path.join(currentDir, '.git');
+      const nodeModulesPath = path.join(currentDir, 'node_modules');
+      
+      if (fs.existsSync(packageJsonPath) || fs.existsSync(gitPath) || fs.existsSync(nodeModulesPath)) {
+        return currentDir;
+      }
+      
+      // Move up one directory
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) break; // Reached filesystem root
+      currentDir = parentDir;
+    }
+    
+    // If no project root found, use the original baseDir (fallback)
+    return startDir;
+  }
+
   // Analyze headings (no auto-fix, only suggestions)
   async analyzeHeadings(directory = '.') {
     console.log(chalk.blue('📑 Analyzing heading structure...'));
@@ -4359,70 +4505,77 @@ class AccessibilityFixer {
       const totalRoleIssues = roleResults.reduce((sum, r) => sum + (r.issues || 0), 0);
       results.steps.push({ step: 3, name: 'Role attributes', fixed: roleFixed, issues: totalRoleIssues });
       
-      // Step 4: Form labels
-      console.log(chalk.blue('📋 Step 4: Form labels...'));
+      // Step 4: Aria-label attributes
+      console.log(chalk.blue('🏷️ Step 4: Aria-label attributes...'));
+      const ariaResults = await this.fixAriaLabels(directory);
+      const ariaFixed = ariaResults.filter(r => r.status === 'processed' && r.changes > 0).length;
+      const totalAriaIssues = ariaResults.reduce((sum, r) => sum + (r.changes || 0), 0);
+      results.steps.push({ step: 4, name: 'Aria-label attributes', fixed: ariaFixed, issues: totalAriaIssues });
+      
+      // Step 5: Form labels
+      console.log(chalk.blue('📋 Step 5: Form labels...'));
       const formResults = await this.fixFormLabels(directory);
       const formFixed = formResults.filter(r => r.status === 'fixed').length;
       const totalFormIssues = formResults.reduce((sum, r) => sum + (r.issues || 0), 0);
-      results.steps.push({ step: 4, name: 'Form labels', fixed: formFixed, issues: totalFormIssues });
+      results.steps.push({ step: 5, name: 'Form labels', fixed: formFixed, issues: totalFormIssues });
       
-      // Step 5: Nested interactive controls (NEW!)
-      console.log(chalk.blue('🎯 Step 5: Nested interactive controls...'));
+      // Step 6: Nested interactive controls (NEW!)
+      console.log(chalk.blue('🎯 Step 6: Nested interactive controls...'));
       const nestedResults = await this.fixNestedInteractiveControls(directory);
       const nestedFixed = nestedResults.filter(r => r.status === 'fixed').length;
       const totalNestedIssues = nestedResults.reduce((sum, r) => sum + (r.issues || 0), 0);
-      results.steps.push({ step: 5, name: 'Nested interactive controls', fixed: nestedFixed, issues: totalNestedIssues });
+      results.steps.push({ step: 6, name: 'Nested interactive controls', fixed: nestedFixed, issues: totalNestedIssues });
       
-      // Step 6: Button names
-      console.log(chalk.blue('🔘 Step 6: Button names...'));
+      // Step 7: Button names
+      console.log(chalk.blue('🔘 Step 7: Button names...'));
       const buttonResults = await this.fixButtonNames(directory);
       const buttonFixed = buttonResults.filter(r => r.status === 'fixed').length;
       const totalButtonIssues = buttonResults.reduce((sum, r) => sum + (r.issues || 0), 0);
-      results.steps.push({ step: 6, name: 'Button names', fixed: buttonFixed, issues: totalButtonIssues });
+      results.steps.push({ step: 7, name: 'Button names', fixed: buttonFixed, issues: totalButtonIssues });
       
-      // Step 7: Link names
-      console.log(chalk.blue('🔗 Step 7: Link names...'));
+      // Step 8: Link names
+      console.log(chalk.blue('🔗 Step 8: Link names...'));
       const linkResults = await this.fixLinkNames(directory);
       const linkFixed = linkResults.filter(r => r.status === 'fixed').length;
       const totalLinkIssues = linkResults.reduce((sum, r) => sum + (r.issues || 0), 0);
-      results.steps.push({ step: 7, name: 'Link names', fixed: linkFixed, issues: totalLinkIssues });
+      results.steps.push({ step: 8, name: 'Link names', fixed: linkFixed, issues: totalLinkIssues });
       
-      // Step 8: Landmarks
-      console.log(chalk.blue('🏛️ Step 8: Landmarks...'));
+      // Step 9: Landmarks
+      console.log(chalk.blue('🏛️ Step 9: Landmarks...'));
       const landmarkResults = await this.fixLandmarks(directory);
       const landmarkFixed = landmarkResults.filter(r => r.status === 'fixed').length;
       const totalLandmarkIssues = landmarkResults.reduce((sum, r) => sum + (r.issues || 0), 0);
-      results.steps.push({ step: 8, name: 'Landmarks', fixed: landmarkFixed, issues: totalLandmarkIssues });
+      results.steps.push({ step: 9, name: 'Landmarks', fixed: landmarkFixed, issues: totalLandmarkIssues });
       
-      // Step 9: Heading analysis
-      console.log(chalk.blue('📑 Step 9: Heading analysis...'));
+      // Step 10: Heading analysis
+      console.log(chalk.blue('📑 Step 10: Heading analysis...'));
       const headingResults = await this.analyzeHeadings(directory);
       const totalHeadingSuggestions = headingResults.reduce((sum, r) => sum + (r.issues || 0), 0);
-      results.steps.push({ step: 9, name: 'Heading analysis', suggestions: totalHeadingSuggestions });
+      results.steps.push({ step: 10, name: 'Heading analysis', suggestions: totalHeadingSuggestions });
       console.log(chalk.gray('💡 Heading issues require manual review and cannot be auto-fixed'));
       
-      // Step 10: Broken links and missing resources check
-      console.log(chalk.blue('🔗 Step 10a: External links check...'));
+      // Step 11: Broken links and missing resources check
+      console.log(chalk.blue('🔗 Step 11a: External links check...'));
       const brokenLinksResults = await this.checkBrokenLinks(directory);
       const totalBrokenLinks = brokenLinksResults.reduce((sum, r) => sum + (r.issues || 0), 0);
-      results.steps.push({ step: '10a', name: 'External links check', issues: totalBrokenLinks });
+      results.steps.push({ step: '11a', name: 'External links check', issues: totalBrokenLinks });
       
-      console.log(chalk.blue('📁 Step 10b: Missing resources check...'));
+      console.log(chalk.blue('📁 Step 11b: Missing resources check...'));
       const missingResourcesResults = await this.check404Resources(directory);
       const totalMissingResources = missingResourcesResults.reduce((sum, r) => sum + (r.issues || 0), 0);
-      results.steps.push({ step: '10b', name: 'Missing resources check', issues: totalMissingResources });
+      results.steps.push({ step: '11b', name: 'Missing resources check', issues: totalMissingResources });
       
       console.log(chalk.gray('💡 Link and resource issues require manual review and cannot be auto-fixed'));
       
-      // Step 11: Cleanup duplicate roles
-      console.log(chalk.blue('🧹 Step 11: Cleanup duplicate roles...'));
+      // Step 12: Cleanup duplicate roles
+      console.log(chalk.blue('🧹 Step 12: Cleanup duplicate roles...'));
       const cleanupResults = await this.cleanupDuplicateRoles(directory);
       const cleanupFixed = cleanupResults.filter(r => r.status === 'fixed').length;
-      results.steps.push({ step: 11, name: 'Cleanup duplicate roles', fixed: cleanupFixed });
+      results.steps.push({ step: 12, name: 'Cleanup duplicate roles', fixed: cleanupFixed });
       
       // Calculate totals
       results.totalFiles = Math.max(
-        langResults.length, altResults.length, roleResults.length, formResults.length,
+        langResults.length, altResults.length, roleResults.length, ariaResults.length, formResults.length,
         nestedResults.length, buttonResults.length, linkResults.length, landmarkResults.length, 
         headingResults.length, brokenLinksResults.length, cleanupResults.length
       );
@@ -5500,49 +5653,117 @@ class AccessibilityFixer {
     return files;
   }
 
-  // Check for unused files in the project
+  // Check for unused files in the project - enhanced for comprehensive project-wide scanning
   async checkUnusedFiles(directory = '.') {
-    console.log(chalk.blue('🗂️ Checking for unused files...'));
+    console.log(chalk.blue('🗂️ Analyzing unused files across entire project...'));
     
-    const results = [];
-    const allFiles = await this.findAllProjectFiles(directory);
-    const referencedFiles = await this.findReferencedFiles(directory);
+    const startTime = Date.now();
     
-    // Normalize paths for comparison
-    const normalizedReferenced = new Set();
-    referencedFiles.forEach(file => {
-      normalizedReferenced.add(path.resolve(file));
-    });
+    // Find project root for comprehensive scanning
+    const projectRoot = this.findProjectRoot(directory);
+    console.log(chalk.gray(`📁 Project root: ${path.relative(process.cwd(), projectRoot) || '.'}`));
+    
+    // Get all project files from root (comprehensive scan)
+    const allFiles = await this.findAllProjectFiles(projectRoot);
+    console.log(chalk.gray(`📊 Found ${allFiles.length} total files in project`));
+    
+    // Get referenced files from entire project (not just target directory)
+    const referencedFiles = await this.findReferencedFiles(projectRoot);
+    console.log(chalk.gray(`🔍 Found ${referencedFiles.size} referenced files`));
+    
+    // Find unused files
+    const unusedFiles = [];
     
     for (const file of allFiles) {
-      const absolutePath = path.resolve(file);
-      
-      // Skip certain files that are typically not referenced directly
+      // Skip certain directories and files that shouldn't be considered "unused"
       if (this.shouldSkipUnusedCheck(file)) {
         continue;
       }
       
-      if (!normalizedReferenced.has(absolutePath)) {
-        const relativePath = path.relative(directory, file);
+      // Check if file is referenced anywhere in the project
+      const relativePath = path.relative(projectRoot, file);
+      const isReferenced = this.isFileReferenced(file, relativePath, referencedFiles, projectRoot);
+      
+      if (!isReferenced) {
+        const stats = await require('fs').promises.stat(file);
+        const fileSize = this.formatFileSize(stats.size);
         const fileType = this.getFileType(file);
         
-        console.log(chalk.yellow(`  🗑️ Unused ${fileType}: ${relativePath}`));
-        
-        results.push({
-          type: `🗑️ Unused ${fileType}`,
-          description: `File not referenced anywhere: ${relativePath}`,
-          suggestion: `Consider removing if truly unused: ${relativePath}`,
-          filePath: file,
-          fileType: fileType,
-          relativePath: relativePath
+        unusedFiles.push({
+          path: file,
+          relativePath: relativePath,
+          size: stats.size,
+          formattedSize: fileSize,
+          type: fileType,
+          description: `File not referenced anywhere in project: ${relativePath}`,
+          suggestion: `Consider removing if truly unused: ${relativePath}`
         });
       }
     }
     
-    console.log(chalk.blue(`\n📊 Summary: Found ${results.length} potentially unused files`));
-    console.log(chalk.gray('💡 Review carefully before removing - some files may be referenced dynamically'));
+    // Sort by size (largest first)
+    unusedFiles.sort((a, b) => b.size - a.size);
     
-    return results;
+    // Display results
+    if (unusedFiles.length === 0) {
+      console.log(chalk.green('✅ No unused files found! All files are properly referenced.'));
+    } else {
+      console.log(chalk.yellow(`\n📋 Found ${unusedFiles.length} potentially unused files:`));
+      
+      unusedFiles.forEach((file, index) => {
+        const icon = this.getFileIcon(file.type);
+        console.log(chalk.yellow(`  ${index + 1}. ${icon} ${file.relativePath} (${file.formattedSize})`));
+      });
+      
+      const totalSize = unusedFiles.reduce((sum, file) => sum + file.size, 0);
+      console.log(chalk.blue(`\n📊 Total unused file size: ${this.formatFileSize(totalSize)}`));
+      console.log(chalk.gray('💡 Review these files before deleting - some may be used dynamically or required for deployment'));
+    }
+    
+    const endTime = Date.now();
+    console.log(chalk.gray(`⏱️ Analysis completed in ${endTime - startTime}ms`));
+    
+    return {
+      unusedFiles: unusedFiles,
+      totalFiles: allFiles.length,
+      referencedFiles: referencedFiles.size,
+      unusedCount: unusedFiles.length,
+      totalUnusedSize: unusedFiles.reduce((sum, file) => sum + file.size, 0)
+    };
+  }
+
+  // Enhanced file reference checking
+  isFileReferenced(filePath, relativePath, referencedFiles, projectRoot) {
+    // Check various possible reference formats
+    const possibleRefs = [
+      relativePath,                                    // relative/to/file.ext
+      '/' + relativePath,                              // /relative/to/file.ext  
+      './' + relativePath,                             // ./relative/to/file.ext
+      '../' + relativePath,                            // ../relative/to/file.ext
+      path.basename(filePath),                         // file.ext
+      '/' + path.basename(filePath),                   // /file.ext
+      relativePath.replace(/\\/g, '/'),                // normalize windows paths
+      '/' + relativePath.replace(/\\/g, '/'),          // /normalized/path
+      relativePath.replace(/^\.\//, ''),               // remove leading ./
+      relativePath.replace(/^\//, ''),                 // remove leading /
+    ];
+    
+    // Check if any reference format exists
+    for (const ref of possibleRefs) {
+      if (referencedFiles.has(ref)) {
+        return true;
+      }
+    }
+    
+    // Check for partial matches (for dynamic imports)
+    const fileName = path.basename(filePath, path.extname(filePath));
+    for (const ref of referencedFiles) {
+      if (ref.includes(fileName) || ref.includes(relativePath)) {
+        return true;
+      }
+    }
+    
+    return false;
   }
 
   async findAllProjectFiles(directory) {
@@ -5577,46 +5798,103 @@ class AccessibilityFixer {
     return files;
   }
 
+  // Enhanced reference finding across entire project
   async findReferencedFiles(directory) {
-    const referenced = new Set();
-    const htmlFiles = await this.findHtmlFiles(directory);
-    const cssFiles = await this.findCssFiles(directory);
-    const jsFiles = await this.findJsFiles(directory);
+    const referencedFiles = new Set();
     
-    // Find references in HTML files
-    for (const htmlFile of htmlFiles) {
-      try {
-        const content = await fs.readFile(htmlFile, 'utf8');
-        const refs = this.extractFileReferences(content, path.dirname(htmlFile));
-        refs.forEach(ref => referenced.add(ref));
-      } catch (error) {
-        // Skip files we can't read
-      }
-    }
+    // Find all source files that could contain references
+    const sourceFiles = await this.findSourceFiles(directory);
+    console.log(chalk.gray(`🔍 Scanning ${sourceFiles.length} source files for references...`));
     
-    // Find references in CSS files
-    for (const cssFile of cssFiles) {
+    for (const sourceFile of sourceFiles) {
       try {
-        const content = await fs.readFile(cssFile, 'utf8');
-        const refs = this.extractCssReferences(content, path.dirname(cssFile));
-        refs.forEach(ref => referenced.add(ref));
+        const content = await fs.readFile(sourceFile, 'utf-8');
+        const baseDir = path.dirname(sourceFile);
+        
+        // Extract references based on file type
+        const refs = this.extractAllReferences(content, baseDir, sourceFile);
+        refs.forEach(ref => referencedFiles.add(ref));
+        
       } catch (error) {
-        // Skip files we can't read
+        console.log(chalk.gray(`⚠️ Could not read ${sourceFile}: ${error.message}`));
       }
     }
     
-    // Find references in JS files
-    for (const jsFile of jsFiles) {
+    return referencedFiles;
+  }
+
+  // Find all source files that could contain references
+  async findSourceFiles(directory) {
+    const sourceFiles = [];
+    
+    const walk = async (dir) => {
       try {
-        const content = await fs.readFile(jsFile, 'utf8');
-        const refs = this.extractJsReferences(content, path.dirname(jsFile));
-        refs.forEach(ref => referenced.add(ref));
+        const files = await fs.readdir(dir);
+        
+        for (const file of files) {
+          const filePath = path.join(dir, file);
+          const stat = await fs.stat(filePath);
+          
+          if (stat.isDirectory()) {
+            if (!this.shouldSkipDirectory(file)) {
+              await walk(filePath);
+            }
+          } else {
+            // Include files that could contain references
+            const ext = path.extname(file).toLowerCase();
+            if (['.html', '.htm', '.css', '.js', '.jsx', '.ts', '.tsx', 
+                 '.vue', '.php', '.json', '.md', '.xml', '.svg'].includes(ext)) {
+              sourceFiles.push(filePath);
+            }
+          }
+        }
       } catch (error) {
-        // Skip files we can't read
+        console.log(chalk.gray(`⚠️ Could not read directory ${dir}: ${error.message}`));
       }
+    };
+    
+    await walk(directory);
+    return sourceFiles;
+  }
+
+  // Enhanced reference extraction
+  extractAllReferences(content, baseDir, sourceFile) {
+    const references = new Set();
+    
+    // Get file extension to determine extraction method
+    const ext = path.extname(sourceFile).toLowerCase();
+    
+    if (['.html', '.htm'].includes(ext)) {
+      // HTML references
+      const htmlRefs = this.extractFileReferences(content, baseDir);
+      htmlRefs.forEach(ref => references.add(ref));
+      
+    } else if (ext === '.css') {
+      // CSS references
+      const cssRefs = this.extractCssReferences(content, baseDir);
+      cssRefs.forEach(ref => references.add(ref));
+      
+    } else if (['.js', '.jsx', '.ts', '.tsx'].includes(ext)) {
+      // JavaScript/TypeScript references
+      const jsRefs = this.extractJsReferences(content, baseDir);
+      jsRefs.forEach(ref => references.add(ref));
+      
+      // Also extract import statements
+      const importRefs = this.extractImportReferences(content, baseDir);
+      importRefs.forEach(ref => references.add(ref));
+      
+    } else if (ext === '.json') {
+      // JSON references (like package.json, config files)
+      const jsonRefs = this.extractJsonReferences(content, baseDir);
+      jsonRefs.forEach(ref => references.add(ref));
+      
+    } else {
+      // Generic file references (for .md, .xml, etc.)
+      const genericRefs = this.extractGenericReferences(content, baseDir);
+      genericRefs.forEach(ref => references.add(ref));
     }
     
-    return Array.from(referenced);
+    return Array.from(references);
   }
 
   extractFileReferences(content, baseDir) {
@@ -6461,6 +6739,128 @@ class AccessibilityFixer {
     
     return sortedBreakdown;
   }
+
+  // Extract import/require statements
+  extractImportReferences(content, baseDir) {
+    const references = [];
+    
+    // ES6 imports and CommonJS requires
+    const importPatterns = [
+      /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g,
+      /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+      /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g,
+      /import\s+['"]([^'"]+)['"]/g
+    ];
+    
+    importPatterns.forEach(pattern => {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const importPath = match[1];
+        
+        // Skip npm packages (don't start with . or /)
+        if (!importPath.startsWith('.') && !importPath.startsWith('/')) {
+          continue;
+        }
+        
+        // Resolve the import path
+        const resolved = this.resolveImportPath(importPath, baseDir);
+        if (resolved) {
+          references.push(resolved);
+        }
+      }
+    });
+    
+    return references;
+  }
+
+  // Extract JSON references
+  extractJsonReferences(content, baseDir) {
+    const references = [];
+    
+    try {
+      const json = JSON.parse(content);
+      
+      // Extract file references from JSON values
+      const extractFromObject = (obj) => {
+        if (typeof obj === 'string') {
+          // Check if it looks like a file path
+          if (obj.includes('.') && (obj.includes('/') || obj.includes('\\'))) {
+            const resolved = this.resolveFilePath(obj, baseDir);
+            if (resolved) {
+              references.push(resolved);
+            }
+          }
+        } else if (typeof obj === 'object' && obj !== null) {
+          Object.values(obj).forEach(value => {
+            if (Array.isArray(value)) {
+              value.forEach(extractFromObject);
+            } else {
+              extractFromObject(value);
+            }
+          });
+        }
+      };
+      
+      extractFromObject(json);
+    } catch (error) {
+      // Invalid JSON, skip
+    }
+    
+    return references;
+  }
+
+  // Extract generic file references
+  extractGenericReferences(content, baseDir) {
+    const references = [];
+    
+    // Look for file-like patterns
+    const patterns = [
+      /['"]((?:\.{1,2}\/)?[^'"]*\.[a-zA-Z0-9]{1,5})['"]/g,  // Quoted file paths
+      /src\s*=\s*['"']([^'"']+)['"']/g,                      // src attributes
+      /href\s*=\s*['"']([^'"']+)['"']/g,                     // href attributes
+      /url\s*\(\s*['"']?([^'"')]+)['"']?\s*\)/g              // CSS url()
+    ];
+    
+    patterns.forEach(pattern => {
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const filePath = match[1];
+        
+        if (this.isLocalFile(filePath)) {
+          const resolved = this.resolveFilePath(filePath, baseDir);
+          if (resolved) {
+            references.push(resolved);
+          }
+        }
+      }
+    });
+    
+    return references;
+  }
+
+  // Resolve import paths (handle extensions and index files)
+  resolveImportPath(importPath, baseDir) {
+    const possiblePaths = [
+      importPath,
+      importPath + '.js',
+      importPath + '.jsx', 
+      importPath + '.ts',
+      importPath + '.tsx',
+      importPath + '/index.js',
+      importPath + '/index.jsx',
+      importPath + '/index.ts', 
+      importPath + '/index.tsx'
+    ];
+    
+    for (const possiblePath of possiblePaths) {
+      const resolved = this.resolveFilePath(possiblePath, baseDir);
+      if (resolved) {
+        return resolved;
+      }
+    }
+    
+    return null;
+  }
 }
 
 module.exports = AccessibilityFixer;