gbu-accessibility-package 1.6.0 → 3.0.0

package/README.md

@@ -33,7 +33,7 @@ npm install gbu-accessibility-package
 ### Basic Usage
 
 ```bash
-# Fix current directory
+# Comprehensive fixes (default mode)
 gbu-a11y
 
 # Preview changes (dry run)
@@ -42,9 +42,6 @@ gbu-a11y --dry-run
 # Fix specific directory
 gbu-a11y ./src
 
-# Comprehensive fixes (recommended)
-gbu-a11y --comprehensive
-
 # Fix specific file
 gbu-a11y index.html
 ```
@@ -62,11 +59,11 @@ Options:
   --backup                 Create backup files (default: enabled)
   --no-backup              Don't create backup files
   --dry-run                Preview changes without applying
-  --comprehensive, --all   Run all fixes including cleanup (recommended)
+  --comprehensive, --all   Run comprehensive fixes (same as default)
   --cleanup-only           Only cleanup duplicate role attributes
-  --alt-only               Only fix alt attributes for images
-  --lang-only              Only fix HTML lang attributes
-  --role-only              Only fix role attributes
+  --alt-only               Fix alt attributes + cleanup
+  --lang-only              Fix HTML lang attributes + cleanup
+  --role-only              Fix role attributes + cleanup
   -h, --help               Show help message
 ```
 
@@ -76,21 +73,21 @@ Options:
 # Basic fixes for current directory (all standard fixes)
 gbu-a11y
 
-# Preview all changes
-gbu-a11y --dry-run --comprehensive
+# Preview all changes (comprehensive by default)
+gbu-a11y --dry-run
 
 # Fix with English language
 gbu-a11y -l en ./public
 
-# Individual fix types
-gbu-a11y --alt-only          # Only fix alt attributes
-gbu-a11y --lang-only         # Only fix lang attributes
-gbu-a11y --role-only         # Only fix role attributes
+# Individual fix types (all include cleanup)
+gbu-a11y --alt-only          # Fix alt attributes + cleanup
+gbu-a11y --lang-only         # Fix lang attributes + cleanup
+gbu-a11y --role-only         # Fix role attributes + cleanup
 gbu-a11y --cleanup-only      # Only cleanup duplicates
 
 # Combine with other options
-gbu-a11y --alt-only --dry-run ./src    # Preview alt fixes only
-gbu-a11y --role-only -l en ./public    # Fix roles with English lang
+gbu-a11y --alt-only --dry-run ./src    # Preview alt fixes + cleanup
+gbu-a11y --role-only -l en ./public    # Role fixes + cleanup with English lang
 
 # Backup options
 gbu-a11y --backup ./dist             # Explicitly enable backups (default)
@@ -308,6 +305,7 @@ The package uses intelligent context analysis to generate meaningful alt text:
 ## 🔒 Safety Features
 
 ### Backup Options
+
 - **Default behavior**: Creates `.backup` files automatically for safety
 - **Disable backups**: Use `--no-backup` for faster processing
 - **Explicit enable**: Use `--backup` to be explicit about backup creation
@@ -324,6 +322,7 @@ gbu-a11y --backup --comprehensive
 ```
 
 ### Other Safety Features
+
 - **Dry run mode** for safe previewing with `--dry-run`
 - **Non-destructive** - only adds missing attributes
 - **Duplicate prevention** - won't add existing attributes

package/cli.js

@@ -18,10 +18,15 @@ const options = {
   dryRun: false,
   help: false,
   cleanupOnly: false,
-  comprehensive: false,
+  comprehensive: false, // Keep for backward compatibility
   altOnly: false,
   langOnly: false,
-  roleOnly: false
+  roleOnly: false,
+  formsOnly: false,
+  buttonsOnly: false,
+  linksOnly: false,
+  landmarksOnly: false,
+  headingsOnly: false
 };
 
 // Parse arguments
@@ -55,7 +60,7 @@ for (let i = 0; i < args.length; i++) {
       break;
     case '--comprehensive':
     case '--all':
-      options.comprehensive = true;
+      options.comprehensive = true; // Keep for backward compatibility
       break;
     case '--alt-only':
       options.altOnly = true;
@@ -66,6 +71,21 @@ for (let i = 0; i < args.length; i++) {
     case '--role-only':
       options.roleOnly = true;
       break;
+    case '--forms-only':
+      options.formsOnly = true;
+      break;
+    case '--buttons-only':
+      options.buttonsOnly = true;
+      break;
+    case '--links-only':
+      options.linksOnly = true;
+      break;
+    case '--landmarks-only':
+      options.landmarksOnly = true;
+      break;
+    case '--headings-only':
+      options.headingsOnly = true;
+      break;
     default:
       if (!arg.startsWith('-')) {
         options.directory = arg;
@@ -86,24 +106,31 @@ Options:
   --backup                 Create backup files (default: enabled)
   --no-backup              Don't create backup files
   --dry-run                Preview changes without applying
-  --comprehensive, --all   Run all fixes including cleanup (recommended)
+  --comprehensive, --all   Run comprehensive fixes (same as default)
   --cleanup-only           Only cleanup duplicate role attributes
-  --alt-only               Only fix alt attributes for images
-  --lang-only              Only fix HTML lang attributes
-  --role-only              Only fix role attributes
+  --alt-only               Fix alt attributes + cleanup
+  --lang-only              Fix HTML lang attributes + cleanup
+  --role-only              Fix role attributes + cleanup
+  --forms-only             Fix form labels + cleanup
+  --buttons-only           Fix button names + cleanup
+  --links-only             Fix link names + cleanup
+  --landmarks-only         Fix landmarks + cleanup
+  --headings-only          Analyze heading structure (no auto-fix)
   -h, --help               Show this help message
 
 Examples:
-  node cli.js                          # Fix current directory (with backups)
-  node cli.js --comprehensive          # Run all fixes including cleanup
-  node cli.js --alt-only               # Only fix alt attributes
-  node cli.js --lang-only              # Only fix lang attributes
-  node cli.js --role-only              # Only fix role attributes
+  node cli.js                          # Comprehensive fixes (default mode)
+  node cli.js --comprehensive          # Comprehensive fixes (same as default)
+  node cli.js --alt-only               # Fix alt attributes + cleanup
+  node cli.js --forms-only             # Fix form labels + cleanup
+  node cli.js --buttons-only           # Fix button names + cleanup
+  node cli.js --links-only             # Fix link names + cleanup
+  node cli.js --landmarks-only         # Fix landmarks + cleanup
+  node cli.js --headings-only          # Analyze heading structure only
   node cli.js --cleanup-only           # Only cleanup duplicate roles
-  node cli.js ./src                    # Fix src directory
-  node cli.js -l en --dry-run ./dist   # Preview fixes for dist directory in English
-  node cli.js --no-backup ./public    # Fix without creating backups
-  node cli.js --backup --comprehensive # Explicitly enable backups with all fixes
+  node cli.js ./src                    # Fix src directory (comprehensive)
+  node cli.js -l en --dry-run ./dist   # Preview comprehensive fixes in English
+  node cli.js --no-backup ./public    # Comprehensive fixes without backups
 
 Features:
   ✅ Alt attributes for images
@@ -115,6 +142,7 @@ Features:
   process.exit(0);
 }
 
+
 // Helper function to show completion message with backup info
 function showCompletionMessage(options, mode = 'fixes') {
   if (options.dryRun) {
@@ -147,14 +175,30 @@ async function main() {
   });
 
   try {
-    // Handle different modes
-    if (options.comprehensive) {
-      // Run comprehensive fix (all fixes including cleanup)
+    // Handle different modes - All modes now include cleanup
+    if (options.cleanupOnly || options.altOnly || options.langOnly || options.roleOnly || 
+        options.formsOnly || options.buttonsOnly || options.linksOnly || options.landmarksOnly || options.headingsOnly) {
+      // Individual modes - handle each separately, then run cleanup
+    } else {
+      // Default mode: Run comprehensive fix (all fixes including cleanup)
       console.log(chalk.blue('🎯 Running comprehensive accessibility fixes...'));
       const results = await fixer.fixAllAccessibilityIssues(options.directory);
       
       // Results already logged in the method
       return;
+    }
+    
+    // Individual modes
+    if (options.cleanupOnly) {
+      // Only cleanup duplicate roles
+      console.log(chalk.blue('🧹 Running cleanup for duplicate role attributes...'));
+      const cleanupResults = await fixer.cleanupDuplicateRoles(options.directory);
+      const cleanupFixed = cleanupResults.filter(r => r.status === 'fixed').length;
+      
+      console.log(chalk.green(`\n✅ Cleaned duplicate roles in ${cleanupFixed} files`));
+      
+      showCompletionMessage(options, 'Cleanup');
+      return;
       
     } else if (options.cleanupOnly) {
       // Only cleanup duplicate roles
@@ -168,90 +212,143 @@ async function main() {
       return;
       
     } else if (options.altOnly) {
-      // Only fix alt attributes
-      console.log(chalk.blue('🖼️ Running alt attribute fixes only...'));
+      // Fix alt attributes + cleanup
+      console.log(chalk.blue('🖼️ Running alt attribute fixes + cleanup...'));
       const altResults = await fixer.fixEmptyAltAttributes(options.directory);
       const altFixed = altResults.filter(r => r.status === 'fixed').length;
       const totalAltIssues = altResults.reduce((sum, r) => sum + (r.issues || 0), 0);
       
       console.log(chalk.green(`\n✅ Fixed alt attributes in ${altFixed} files (${totalAltIssues} issues)`));
       
-      showCompletionMessage(options, 'Alt attribute fixes');
+      // Run cleanup
+      console.log(chalk.blue('\n🧹 Running cleanup for duplicate role attributes...'));
+      const cleanupResults = await fixer.cleanupDuplicateRoles(options.directory);
+      const cleanupFixed = cleanupResults.filter(r => r.status === 'fixed').length;
+      console.log(chalk.green(`✅ Cleaned duplicate roles in ${cleanupFixed} files`));
+      
+      showCompletionMessage(options, 'Alt attribute fixes + cleanup');
       return;
       
     } else if (options.langOnly) {
-      // Only fix lang attributes
-      console.log(chalk.blue('📝 Running HTML lang attribute fixes only...'));
+      // Fix lang attributes + cleanup
+      console.log(chalk.blue('📝 Running HTML lang attribute fixes + cleanup...'));
       const langResults = await fixer.fixHtmlLang(options.directory);
       const langFixed = langResults.filter(r => r.status === 'fixed').length;
       
       console.log(chalk.green(`\n✅ Fixed lang attributes in ${langFixed} files`));
       
-      showCompletionMessage(options, 'Lang attribute fixes');
+      // Run cleanup
+      console.log(chalk.blue('\n🧹 Running cleanup for duplicate role attributes...'));
+      const cleanupResults = await fixer.cleanupDuplicateRoles(options.directory);
+      const cleanupFixed = cleanupResults.filter(r => r.status === 'fixed').length;
+      console.log(chalk.green(`✅ Cleaned duplicate roles in ${cleanupFixed} files`));
+      
+      showCompletionMessage(options, 'Lang attribute fixes + cleanup');
       return;
       
     } else if (options.roleOnly) {
-      // Only fix role attributes
-      console.log(chalk.blue('🎭 Running role attribute fixes only...'));
+      // Fix role attributes + cleanup
+      console.log(chalk.blue('🎭 Running role attribute fixes + cleanup...'));
       const roleResults = await fixer.fixRoleAttributes(options.directory);
       const roleFixed = roleResults.filter(r => r.status === 'fixed').length;
       const totalRoleIssues = roleResults.reduce((sum, r) => sum + (r.issues || 0), 0);
       
       console.log(chalk.green(`\n✅ Fixed role attributes in ${roleFixed} files (${totalRoleIssues} issues)`));
       
-      showCompletionMessage(options, 'Role attribute fixes');
+      // Run cleanup
+      console.log(chalk.blue('\n🧹 Running cleanup for duplicate role attributes...'));
+      const cleanupResults = await fixer.cleanupDuplicateRoles(options.directory);
+      const cleanupFixed = cleanupResults.filter(r => r.status === 'fixed').length;
+      console.log(chalk.green(`✅ Cleaned duplicate roles in ${cleanupFixed} files`));
+      
+      showCompletionMessage(options, 'Role attribute fixes + cleanup');
+      return;
+      
+    } else if (options.formsOnly) {
+      // Fix form labels + cleanup
+      console.log(chalk.blue('📋 Running form label fixes + cleanup...'));
+      const formResults = await fixer.fixFormLabels(options.directory);
+      const formFixed = formResults.filter(r => r.status === 'fixed').length;
+      const totalFormIssues = formResults.reduce((sum, r) => sum + (r.issues || 0), 0);
+      
+      console.log(chalk.green(`\n✅ Fixed form labels in ${formFixed} files (${totalFormIssues} issues)`));
+      
+      // Run cleanup
+      console.log(chalk.blue('\n🧹 Running cleanup for duplicate role attributes...'));
+      const cleanupResults = await fixer.cleanupDuplicateRoles(options.directory);
+      const cleanupFixed = cleanupResults.filter(r => r.status === 'fixed').length;
+      console.log(chalk.green(`✅ Cleaned duplicate roles in ${cleanupFixed} files`));
+      
+      showCompletionMessage(options, 'Form label fixes + cleanup');
+      return;
+      
+    } else if (options.buttonsOnly) {
+      // Fix button names + cleanup
+      console.log(chalk.blue('🔘 Running button name fixes + cleanup...'));
+      const buttonResults = await fixer.fixButtonNames(options.directory);
+      const buttonFixed = buttonResults.filter(r => r.status === 'fixed').length;
+      const totalButtonIssues = buttonResults.reduce((sum, r) => sum + (r.issues || 0), 0);
+      
+      console.log(chalk.green(`\n✅ Fixed button names in ${buttonFixed} files (${totalButtonIssues} issues)`));
+      
+      // Run cleanup
+      console.log(chalk.blue('\n🧹 Running cleanup for duplicate role attributes...'));
+      const cleanupResults = await fixer.cleanupDuplicateRoles(options.directory);
+      const cleanupFixed = cleanupResults.filter(r => r.status === 'fixed').length;
+      console.log(chalk.green(`✅ Cleaned duplicate roles in ${cleanupFixed} files`));
+      
+      showCompletionMessage(options, 'Button name fixes + cleanup');
+      return;
+      
+    } else if (options.linksOnly) {
+      // Fix link names + cleanup
+      console.log(chalk.blue('🔗 Running link name fixes + cleanup...'));
+      const linkResults = await fixer.fixLinkNames(options.directory);
+      const linkFixed = linkResults.filter(r => r.status === 'fixed').length;
+      const totalLinkIssues = linkResults.reduce((sum, r) => sum + (r.issues || 0), 0);
+      
+      console.log(chalk.green(`\n✅ Fixed link names in ${linkFixed} files (${totalLinkIssues} issues)`));
+      
+      // Run cleanup
+      console.log(chalk.blue('\n🧹 Running cleanup for duplicate role attributes...'));
+      const cleanupResults = await fixer.cleanupDuplicateRoles(options.directory);
+      const cleanupFixed = cleanupResults.filter(r => r.status === 'fixed').length;
+      console.log(chalk.green(`✅ Cleaned duplicate roles in ${cleanupFixed} files`));
+      
+      showCompletionMessage(options, 'Link name fixes + cleanup');
+      return;
+      
+    } else if (options.landmarksOnly) {
+      // Fix landmarks + cleanup
+      console.log(chalk.blue('🏛️ Running landmark fixes + cleanup...'));
+      const landmarkResults = await fixer.fixLandmarks(options.directory);
+      const landmarkFixed = landmarkResults.filter(r => r.status === 'fixed').length;
+      const totalLandmarkIssues = landmarkResults.reduce((sum, r) => sum + (r.issues || 0), 0);
+      
+      console.log(chalk.green(`\n✅ Fixed landmarks in ${landmarkFixed} files (${totalLandmarkIssues} issues)`));
+      
+      // Run cleanup
+      console.log(chalk.blue('\n🧹 Running cleanup for duplicate role attributes...'));
+      const cleanupResults = await fixer.cleanupDuplicateRoles(options.directory);
+      const cleanupFixed = cleanupResults.filter(r => r.status === 'fixed').length;
+      console.log(chalk.green(`✅ Cleaned duplicate roles in ${cleanupFixed} files`));
+      
+      showCompletionMessage(options, 'Landmark fixes + cleanup');
+      return;
+      
+    } else if (options.headingsOnly) {
+      // Analyze headings only (no fixes, no cleanup)
+      console.log(chalk.blue('📑 Running heading analysis only...'));
+      const headingResults = await fixer.analyzeHeadings(options.directory);
+      const totalSuggestions = headingResults.reduce((sum, r) => sum + (r.issues || 0), 0);
+      
+      console.log(chalk.green(`\n✅ Analyzed headings in ${headingResults.length} files (${totalSuggestions} suggestions)`));
+      console.log(chalk.gray('💡 Heading issues require manual review and cannot be auto-fixed'));
+      
+      showCompletionMessage(options, 'Heading analysis');
       return;
     }
 
-    // Standard mode - run individual fixes
-    // Fix HTML lang attributes
-    console.log(chalk.yellow('📝 Step 1: Fixing HTML lang attributes...'));
-    const langResults = await fixer.fixHtmlLang(options.directory);
-    const langFixed = langResults.filter(r => r.status === 'fixed').length;
-    console.log(chalk.green(`✅ Fixed lang attributes in ${langFixed} files`));
-    console.log('');
-
-    // Fix alt attributes
-    console.log(chalk.yellow('🖼️  Step 2: Fixing alt attributes...'));
-    const altResults = await fixer.fixEmptyAltAttributes(options.directory);
-    const altFixed = altResults.filter(r => r.status === 'fixed').length;
-    const totalAltIssues = altResults.reduce((sum, r) => sum + (r.issues || 0), 0);
-    console.log(chalk.green(`✅ Fixed alt attributes in ${altFixed} files (${totalAltIssues} issues)`));
-    console.log('');
-
-    // Fix role attributes
-    console.log(chalk.yellow('🎭 Step 3: Fixing role attributes...'));
-    const roleResults = await fixer.fixRoleAttributes(options.directory);
-    const roleFixed = roleResults.filter(r => r.status === 'fixed').length;
-    const totalRoleIssues = roleResults.reduce((sum, r) => sum + (r.issues || 0), 0);
-    console.log(chalk.green(`✅ Fixed role attributes in ${roleFixed} files (${totalRoleIssues} issues)`));
-    console.log('');
-
-    // Summary
-    const totalFiles = new Set([
-      ...langResults.map(r => r.file),
-      ...altResults.map(r => r.file),
-      ...roleResults.map(r => r.file)
-    ]).size;
-
-    const totalFixed = new Set([
-      ...langResults.filter(r => r.status === 'fixed').map(r => r.file),
-      ...altResults.filter(r => r.status === 'fixed').map(r => r.file),
-      ...roleResults.filter(r => r.status === 'fixed').map(r => r.file)
-    ]).size;
-
-    const totalIssues = totalAltIssues + totalRoleIssues + langFixed;
-
-    console.log(chalk.blue('📊 Summary:'));
-    console.log(chalk.white(`   Total files scanned: ${totalFiles}`));
-    console.log(chalk.green(`   Files fixed: ${totalFixed}`));
-    console.log(chalk.yellow(`   Total issues resolved: ${totalIssues}`));
-    
-    showCompletionMessage(options, 'All accessibility fixes');
-    
-    // Suggest cleanup if not comprehensive mode
-    console.log(chalk.blue('\n💡 Pro tip: Use --comprehensive to include duplicate role cleanup!'));
-
   } catch (error) {
     console.error(chalk.red('❌ Error occurred:'), error.message);
     process.exit(1);

package/demo/advanced-test.html

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Advanced Accessibility Test</title>
+</head>
+<body>
+    <h1>Advanced Accessibility Test</h1>
+    
+    <!-- Form issues -->
+    <form>
+        <input type="text" placeholder="Name">
+        <input type="email" id="email">
+        <input type="password">
+        <input type="submit">
+    </form>
+    
+    <!-- Button issues -->
+    <button></button>
+    <button onclick="alert('test')"></button>
+    <input type="button">
+    
+    <!-- Link issues -->
+    <a href="/home"></a>
+    <a href="/more">Click here</a>
+    <a href="/read">Read more</a>
+    <a href="/image"><img src="icon.png"></a>
+    
+    <!-- Heading issues -->
+    <h3>Skipped h2</h3>
+    <h1>Second h1</h1>
+    <h4></h4>
+    
+    <!-- Landmark issues -->
+    <div class="content">
+        <p>Main content without landmark</p>
+    </div>
+    
+    <ul class="navigation">
+        <li><a href="/home">Home</a></li>
+        <li><a href="/about">About</a></li>
+    </ul>
+</body>
+</html>

package/demo/advanced-test.html.backup

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Advanced Accessibility Test</title>
+</head>
+<body>
+    <h1>Advanced Accessibility Test</h1>
+    
+    <!-- Form issues -->
+    <form>
+        <input type="text" placeholder="Name">
+        <input type="email" id="email">
+        <input type="password">
+        <input type="submit">
+    </form>
+    
+    <!-- Button issues -->
+    <button></button>
+    <button onclick="alert('test')"></button>
+    <input type="button">
+    
+    <!-- Link issues -->
+    <a href="/home"></a>
+    <a href="/more">Click here</a>
+    <a href="/read">Read more</a>
+    <a href="/image"><img src="icon.png"></a>
+    
+    <!-- Heading issues -->
+    <h3>Skipped h2</h3>
+    <h1>Second h1</h1>
+    <h4></h4>
+    
+    <!-- Landmark issues -->
+    <div class="content">
+        <p>Main content without landmark</p>
+    </div>
+    
+    <ul class="navigation">
+        <li><a href="/home">Home</a></li>
+        <li><a href="/about">About</a></li>
+    </ul>
+</body>
+</html>

package/demo/comprehensive-test.html

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Comprehensive Test</title>
+</head>
+<body>
+    <h1>Comprehensive Test File</h1>
+    
+    <!-- Missing alt -->
+    <img src="test.jpg">
+    
+    <!-- Missing role -->
+    <a href="/home">Home</a>
+    
+    <!-- Duplicate roles -->
+    <img src="dup.jpg" alt="Duplicate" role="img" role="img">
+    
+    <p>This tests comprehensive mode as default.</p>
+</body>
+</html>

package/demo/comprehensive-test.html.backup

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>Comprehensive Test</title>
+</head>
+<body>
+    <h1>Comprehensive Test File</h1>
+    
+    <!-- Missing alt -->
+    <img src="test.jpg">
+    
+    <!-- Missing role -->
+    <a href="/home">Home</a>
+    
+    <!-- Duplicate roles -->
+    <img src="dup.jpg" alt="Duplicate" role="img" role="img">
+    
+    <p>This tests comprehensive mode as default.</p>
+</body>
+</html>

package/lib/fixer.js

@@ -938,7 +938,12 @@ class AccessibilityFixer {
       lang: [],
       alt: [],
       roles: [],
-      cleanup: []
+      cleanup: [],
+      forms: [],
+      buttons: [],
+      links: [],
+      landmarks: [],
+      headings: [] // Analysis only
     };
     
     try {
@@ -954,8 +959,28 @@ class AccessibilityFixer {
       console.log(chalk.yellow('\n🎭 Step 3: Role attributes...'));
       results.roles = await this.fixRoleAttributes(directory);
       
-      // Step 4: Cleanup duplicate roles
-      console.log(chalk.yellow('\n🧹 Step 4: Cleanup duplicate roles...'));
+      // Step 4: Fix form labels
+      console.log(chalk.yellow('\n📋 Step 4: Form labels...'));
+      results.forms = await this.fixFormLabels(directory);
+      
+      // Step 5: Fix button names
+      console.log(chalk.yellow('\n🔘 Step 5: Button names...'));
+      results.buttons = await this.fixButtonNames(directory);
+      
+      // Step 6: Fix link names
+      console.log(chalk.yellow('\n🔗 Step 6: Link names...'));
+      results.links = await this.fixLinkNames(directory);
+      
+      // Step 7: Fix landmarks
+      console.log(chalk.yellow('\n🏛️ Step 7: Landmarks...'));
+      results.landmarks = await this.fixLandmarks(directory);
+      
+      // Step 8: Analyze headings (no auto-fix)
+      console.log(chalk.yellow('\n📑 Step 8: Heading analysis...'));
+      results.headings = await this.analyzeHeadings(directory);
+      
+      // Step 9: Cleanup duplicate roles
+      console.log(chalk.yellow('\n🧹 Step 9: Cleanup duplicate roles...'));
       results.cleanup = await this.cleanupDuplicateRoles(directory);
       
       // Summary
@@ -963,6 +988,10 @@ class AccessibilityFixer {
         ...results.lang.map(r => r.file),
         ...results.alt.map(r => r.file),
         ...results.roles.map(r => r.file),
+        ...results.forms.map(r => r.file),
+        ...results.buttons.map(r => r.file),
+        ...results.links.map(r => r.file),
+        ...results.landmarks.map(r => r.file),
         ...results.cleanup.map(r => r.file)
       ]).size;
       
@@ -970,6 +999,10 @@ class AccessibilityFixer {
         ...results.lang.filter(r => r.status === 'fixed').map(r => r.file),
         ...results.alt.filter(r => r.status === 'fixed').map(r => r.file),
         ...results.roles.filter(r => r.status === 'fixed').map(r => r.file),
+        ...results.forms.filter(r => r.status === 'fixed').map(r => r.file),
+        ...results.buttons.filter(r => r.status === 'fixed').map(r => r.file),
+        ...results.links.filter(r => r.status === 'fixed').map(r => r.file),
+        ...results.landmarks.filter(r => r.status === 'fixed').map(r => r.file),
         ...results.cleanup.filter(r => r.status === 'fixed').map(r => r.file)
       ]).size;
       
@@ -977,6 +1010,10 @@ class AccessibilityFixer {
         results.lang.filter(r => r.status === 'fixed').length +
         results.alt.reduce((sum, r) => sum + (r.issues || 0), 0) +
         results.roles.reduce((sum, r) => sum + (r.issues || 0), 0) +
+        results.forms.reduce((sum, r) => sum + (r.issues || 0), 0) +
+        results.buttons.reduce((sum, r) => sum + (r.issues || 0), 0) +
+        results.links.reduce((sum, r) => sum + (r.issues || 0), 0) +
+        results.landmarks.reduce((sum, r) => sum + (r.issues || 0), 0) +
         results.cleanup.filter(r => r.status === 'fixed').length;
       
       console.log(chalk.green('\n🎉 All accessibility fixes completed!'));
@@ -997,6 +1034,644 @@ class AccessibilityFixer {
     }
   }
 
+  // Fix form labels
+  async fixFormLabels(directory = '.') {
+    console.log(chalk.blue('📋 Fixing form labels...'));
+    
+    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 issues = this.analyzeFormLabels(content);
+        
+        if (issues.length > 0) {
+          console.log(chalk.cyan(`\n📁 ${file}:`));
+          issues.forEach(issue => {
+            console.log(chalk.yellow(`  ${issue.type}: ${issue.description}`));
+            totalIssuesFound++;
+          });
+        }
+        
+        const fixed = this.fixFormLabelsInContent(content);
+        
+        if (fixed !== content) {
+          if (this.config.backupFiles) {
+            await fs.writeFile(`${file}.backup`, content);
+          }
+          
+          if (!this.config.dryRun) {
+            await fs.writeFile(file, fixed);
+          }
+          
+          console.log(chalk.green(`✅ Fixed form labels in: ${file}`));
+          results.push({ file, status: 'fixed', issues: issues.length });
+        } else {
+          results.push({ file, status: 'no-change', issues: issues.length });
+        }
+      } 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} form label issues across ${results.length} files`));
+    return results;
+  }
+
+  analyzeFormLabels(content) {
+    const issues = [];
+    
+    // Find input elements without labels
+    const inputPattern = /<input[^>]*>/gi;
+    const inputs = content.match(inputPattern) || [];
+    
+    inputs.forEach((input, index) => {
+      const hasId = /id\s*=\s*["']([^"']+)["']/i.test(input);
+      const hasAriaLabel = /aria-label\s*=/i.test(input);
+      const hasAriaLabelledby = /aria-labelledby\s*=/i.test(input);
+      const inputType = input.match(/type\s*=\s*["']([^"']+)["']/i);
+      const type = inputType ? inputType[1].toLowerCase() : 'text';
+      
+      // Skip certain input types that don't need labels
+      if (['hidden', 'submit', 'button', 'reset'].includes(type)) {
+        return;
+      }
+      
+      if (hasId) {
+        const idMatch = input.match(/id\s*=\s*["']([^"']+)["']/i);
+        const id = idMatch[1];
+        const labelPattern = new RegExp(`<label[^>]*for\\s*=\\s*["']${id}["'][^>]*>`, 'i');
+        const hasLabel = labelPattern.test(content);
+        
+        if (!hasLabel && !hasAriaLabel && !hasAriaLabelledby) {
+          issues.push({
+            type: '📋 Missing label',
+            description: `Input ${index + 1} (type: ${type}) needs a label or aria-label`,
+            element: input.substring(0, 100) + '...'
+          });
+        }
+      } else if (!hasAriaLabel && !hasAriaLabelledby) {
+        issues.push({
+          type: '📋 Missing label/id',
+          description: `Input ${index + 1} (type: ${type}) needs an id and label, or aria-label`,
+          element: input.substring(0, 100) + '...'
+        });
+      }
+    });
+    
+    return issues;
+  }
+
+  fixFormLabelsInContent(content) {
+    let fixed = content;
+    
+    // Add aria-label to inputs without labels (basic fix)
+    const inputPattern = /<input([^>]*type\s*=\s*["']([^"']+)["'][^>]*)>/gi;
+    
+    fixed = fixed.replace(inputPattern, (match, attributes, type) => {
+      const lowerType = type.toLowerCase();
+      
+      // Skip certain input types
+      if (['hidden', 'submit', 'button', 'reset'].includes(lowerType)) {
+        return match;
+      }
+      
+      const hasAriaLabel = /aria-label\s*=/i.test(match);
+      const hasAriaLabelledby = /aria-labelledby\s*=/i.test(match);
+      const hasId = /id\s*=\s*["']([^"']+)["']/i.test(match);
+      
+      if (!hasAriaLabel && !hasAriaLabelledby) {
+        // Check if there's a corresponding label
+        if (hasId) {
+          const idMatch = match.match(/id\s*=\s*["']([^"']+)["']/i);
+          const id = idMatch[1];
+          const labelPattern = new RegExp(`<label[^>]*for\\s*=\\s*["']${id}["'][^>]*>`, 'i');
+          
+          if (!labelPattern.test(content)) {
+            // Add basic aria-label
+            const labelText = this.generateInputLabel(lowerType);
+            console.log(chalk.yellow(`  📋 Added aria-label="${labelText}" to ${lowerType} input`));
+            return match.replace(/(<input[^>]*?)(\s*>)/i, `$1 aria-label="${labelText}"$2`);
+          }
+        } else {
+          // Add basic aria-label
+          const labelText = this.generateInputLabel(lowerType);
+          console.log(chalk.yellow(`  📋 Added aria-label="${labelText}" to ${lowerType} input`));
+          return match.replace(/(<input[^>]*?)(\s*>)/i, `$1 aria-label="${labelText}"$2`);
+        }
+      }
+      
+      return match;
+    });
+    
+    return fixed;
+  }
+
+  generateInputLabel(type) {
+    const labels = {
+      'text': 'テキスト入力',
+      'email': 'メールアドレス',
+      'password': 'パスワード',
+      'tel': '電話番号',
+      'url': 'URL',
+      'search': '検索',
+      'number': '数値',
+      'date': '日付',
+      'time': '時間',
+      'checkbox': 'チェックボックス',
+      'radio': 'ラジオボタン',
+      'file': 'ファイル選択'
+    };
+    
+    return labels[type] || 'フォーム入力';
+  }
+
+  // Fix button names
+  async fixButtonNames(directory = '.') {
+    console.log(chalk.blue('🔘 Fixing button names...'));
+    
+    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 issues = this.analyzeButtonNames(content);
+        
+        if (issues.length > 0) {
+          console.log(chalk.cyan(`\n📁 ${file}:`));
+          issues.forEach(issue => {
+            console.log(chalk.yellow(`  ${issue.type}: ${issue.description}`));
+            totalIssuesFound++;
+          });
+        }
+        
+        const fixed = this.fixButtonNamesInContent(content);
+        
+        if (fixed !== content) {
+          if (this.config.backupFiles) {
+            await fs.writeFile(`${file}.backup`, content);
+          }
+          
+          if (!this.config.dryRun) {
+            await fs.writeFile(file, fixed);
+          }
+          
+          console.log(chalk.green(`✅ Fixed button names in: ${file}`));
+          results.push({ file, status: 'fixed', issues: issues.length });
+        } else {
+          results.push({ file, status: 'no-change', issues: issues.length });
+        }
+      } 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} button name issues across ${results.length} files`));
+    return results;
+  }
+
+  analyzeButtonNames(content) {
+    const issues = [];
+    
+    // Find buttons without discernible text
+    const buttonPattern = /<button[^>]*>[\s\S]*?<\/button>/gi;
+    const buttons = content.match(buttonPattern) || [];
+    
+    buttons.forEach((button, index) => {
+      const hasAriaLabel = /aria-label\s*=/i.test(button);
+      const hasAriaLabelledby = /aria-labelledby\s*=/i.test(button);
+      const hasTitle = /title\s*=/i.test(button);
+      
+      // Extract text content
+      const textContent = button.replace(/<[^>]*>/g, '').trim();
+      
+      if (!textContent && !hasAriaLabel && !hasAriaLabelledby && !hasTitle) {
+        issues.push({
+          type: '🔘 Empty button',
+          description: `Button ${index + 1} has no discernible text`,
+          element: button.substring(0, 100) + '...'
+        });
+      }
+    });
+    
+    // Find input buttons without names
+    const inputButtonPattern = /<input[^>]*type\s*=\s*["'](button|submit|reset)["'][^>]*>/gi;
+    const inputButtons = content.match(inputButtonPattern) || [];
+    
+    inputButtons.forEach((input, index) => {
+      const hasValue = /value\s*=/i.test(input);
+      const hasAriaLabel = /aria-label\s*=/i.test(input);
+      const hasTitle = /title\s*=/i.test(input);
+      
+      if (!hasValue && !hasAriaLabel && !hasTitle) {
+        issues.push({
+          type: '🔘 Input button without name',
+          description: `Input button ${index + 1} needs value, aria-label, or title`,
+          element: input.substring(0, 100) + '...'
+        });
+      }
+    });
+    
+    return issues;
+  }
+
+  fixButtonNamesInContent(content) {
+    let fixed = content;
+    
+    // Fix empty buttons
+    fixed = fixed.replace(/<button([^>]*)>\s*<\/button>/gi, (match, attributes) => {
+      const hasAriaLabel = /aria-label\s*=/i.test(match);
+      const hasAriaLabelledby = /aria-labelledby\s*=/i.test(match);
+      const hasTitle = /title\s*=/i.test(match);
+      
+      if (!hasAriaLabel && !hasAriaLabelledby && !hasTitle) {
+        console.log(chalk.yellow(`  🔘 Added aria-label to empty button`));
+        return `<button${attributes} aria-label="ボタン">ボタン</button>`;
+      }
+      
+      return match;
+    });
+    
+    // Fix input buttons without value
+    fixed = fixed.replace(/<input([^>]*type\s*=\s*["'](button|submit|reset)["'][^>]*)>/gi, (match, attributes, type) => {
+      const hasValue = /value\s*=/i.test(match);
+      const hasAriaLabel = /aria-label\s*=/i.test(match);
+      const hasTitle = /title\s*=/i.test(match);
+      
+      if (!hasValue && !hasAriaLabel && !hasTitle) {
+        const buttonText = type === 'submit' ? '送信' : type === 'reset' ? 'リセット' : 'ボタン';
+        console.log(chalk.yellow(`  🔘 Added value="${buttonText}" to input ${type} button`));
+        return match.replace(/(<input[^>]*?)(\s*>)/i, `$1 value="${buttonText}"$2`);
+      }
+      
+      return match;
+    });
+    
+    return fixed;
+  }
+
+  // Fix link names
+  async fixLinkNames(directory = '.') {
+    console.log(chalk.blue('🔗 Fixing link names...'));
+    
+    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 issues = this.analyzeLinkNames(content);
+        
+        if (issues.length > 0) {
+          console.log(chalk.cyan(`\n📁 ${file}:`));
+          issues.forEach(issue => {
+            console.log(chalk.yellow(`  ${issue.type}: ${issue.description}`));
+            totalIssuesFound++;
+          });
+        }
+        
+        const fixed = this.fixLinkNamesInContent(content);
+        
+        if (fixed !== content) {
+          if (this.config.backupFiles) {
+            await fs.writeFile(`${file}.backup`, content);
+          }
+          
+          if (!this.config.dryRun) {
+            await fs.writeFile(file, fixed);
+          }
+          
+          console.log(chalk.green(`✅ Fixed link names in: ${file}`));
+          results.push({ file, status: 'fixed', issues: issues.length });
+        } else {
+          results.push({ file, status: 'no-change', issues: issues.length });
+        }
+      } 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} link name issues across ${results.length} files`));
+    return results;
+  }
+
+  analyzeLinkNames(content) {
+    const issues = [];
+    
+    // Find links without discernible text
+    const linkPattern = /<a[^>]*href[^>]*>[\s\S]*?<\/a>/gi;
+    const links = content.match(linkPattern) || [];
+    
+    links.forEach((link, index) => {
+      const hasAriaLabel = /aria-label\s*=/i.test(link);
+      const hasAriaLabelledby = /aria-labelledby\s*=/i.test(link);
+      const hasTitle = /title\s*=/i.test(link);
+      
+      // Extract text content (excluding images)
+      let textContent = link.replace(/<img[^>]*>/gi, '').replace(/<[^>]*>/g, '').trim();
+      
+      // Check for image alt text if link contains only images
+      if (!textContent) {
+        const imgMatch = link.match(/<img[^>]*alt\s*=\s*["']([^"']+)["'][^>]*>/i);
+        if (imgMatch) {
+          textContent = imgMatch[1].trim();
+        }
+      }
+      
+      if (!textContent && !hasAriaLabel && !hasAriaLabelledby && !hasTitle) {
+        issues.push({
+          type: '🔗 Empty link',
+          description: `Link ${index + 1} has no discernible text`,
+          element: link.substring(0, 100) + '...'
+        });
+      } else if (textContent && (textContent.toLowerCase() === 'click here' || textContent.toLowerCase() === 'read more' || textContent.toLowerCase() === 'here')) {
+        issues.push({
+          type: '🔗 Generic link text',
+          description: `Link ${index + 1} has generic text: "${textContent}"`,
+          element: link.substring(0, 100) + '...'
+        });
+      }
+    });
+    
+    return issues;
+  }
+
+  fixLinkNamesInContent(content) {
+    let fixed = content;
+    
+    // Fix empty links
+    fixed = fixed.replace(/<a([^>]*href[^>]*)>\s*<\/a>/gi, (match, attributes) => {
+      const hasAriaLabel = /aria-label\s*=/i.test(match);
+      const hasAriaLabelledby = /aria-labelledby\s*=/i.test(match);
+      const hasTitle = /title\s*=/i.test(match);
+      
+      if (!hasAriaLabel && !hasAriaLabelledby && !hasTitle) {
+        console.log(chalk.yellow(`  🔗 Added aria-label to empty link`));
+        return `<a${attributes} aria-label="リンク">リンク</a>`;
+      }
+      
+      return match;
+    });
+    
+    // Fix links with only images but no alt text
+    fixed = fixed.replace(/<a([^>]*href[^>]*)>(\s*<img[^>]*>\s*)<\/a>/gi, (match, attributes, imgTag) => {
+      const hasAriaLabel = /aria-label\s*=/i.test(match);
+      const hasAlt = /alt\s*=/i.test(imgTag);
+      
+      if (!hasAriaLabel && !hasAlt) {
+        console.log(chalk.yellow(`  🔗 Added aria-label to image link`));
+        return `<a${attributes} aria-label="画像リンク">${imgTag}</a>`;
+      }
+      
+      return match;
+    });
+    
+    return fixed;
+  }
+
+  // Fix landmarks
+  async fixLandmarks(directory = '.') {
+    console.log(chalk.blue('🏛️ Fixing landmarks...'));
+    
+    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 issues = this.analyzeLandmarks(content);
+        
+        if (issues.length > 0) {
+          console.log(chalk.cyan(`\n📁 ${file}:`));
+          issues.forEach(issue => {
+            console.log(chalk.yellow(`  ${issue.type}: ${issue.description}`));
+            totalIssuesFound++;
+          });
+        }
+        
+        const fixed = this.fixLandmarksInContent(content);
+        
+        if (fixed !== content) {
+          if (this.config.backupFiles) {
+            await fs.writeFile(`${file}.backup`, content);
+          }
+          
+          if (!this.config.dryRun) {
+            await fs.writeFile(file, fixed);
+          }
+          
+          console.log(chalk.green(`✅ Fixed landmarks in: ${file}`));
+          results.push({ file, status: 'fixed', issues: issues.length });
+        } else {
+          results.push({ file, status: 'no-change', issues: issues.length });
+        }
+      } 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} landmark issues across ${results.length} files`));
+    return results;
+  }
+
+  analyzeLandmarks(content) {
+    const issues = [];
+    
+    // Check for main landmark
+    const hasMain = /<main[^>]*>/i.test(content) || /role\s*=\s*["']main["']/i.test(content);
+    if (!hasMain) {
+      issues.push({
+        type: '🏛️ Missing main landmark',
+        description: 'Page should have a main landmark',
+        suggestion: 'Add <main> element or role="main"'
+      });
+    }
+    
+    // Check for multiple main landmarks
+    const mainCount = (content.match(/<main[^>]*>/gi) || []).length + 
+                     (content.match(/role\s*=\s*["']main["']/gi) || []).length;
+    if (mainCount > 1) {
+      issues.push({
+        type: '🏛️ Multiple main landmarks',
+        description: `Found ${mainCount} main landmarks, should have only one`,
+        suggestion: 'Keep only one main landmark per page'
+      });
+    }
+    
+    // Check for navigation landmarks
+    const hasNav = /<nav[^>]*>/i.test(content) || /role\s*=\s*["']navigation["']/i.test(content);
+    if (!hasNav) {
+      // Look for navigation-like elements
+      const navLikeElements = content.match(/<(?:ul|div)[^>]*class\s*=\s*["'][^"']*(?:nav|menu|navigation)[^"']*["'][^>]*>/gi);
+      if (navLikeElements && navLikeElements.length > 0) {
+        issues.push({
+          type: '🏛️ Missing navigation landmark',
+          description: 'Navigation elements should have nav tag or role="navigation"',
+          suggestion: 'Use <nav> element or add role="navigation"'
+        });
+      }
+    }
+    
+    return issues;
+  }
+
+  fixLandmarksInContent(content) {
+    let fixed = content;
+    
+    // Add main landmark if missing (basic implementation)
+    const hasMain = /<main[^>]*>/i.test(content) || /role\s*=\s*["']main["']/i.test(content);
+    
+    if (!hasMain) {
+      // Look for content containers that could be main
+      const contentPatterns = [
+        /<div[^>]*class\s*=\s*["'][^"']*(?:content|main|container)[^"']*["'][^>]*>/gi,
+        /<section[^>]*class\s*=\s*["'][^"']*(?:content|main)[^"']*["'][^>]*>/gi
+      ];
+      
+      for (const pattern of contentPatterns) {
+        const matches = fixed.match(pattern);
+        if (matches && matches.length === 1) {
+          // Add role="main" to the first suitable container
+          fixed = fixed.replace(pattern, (match) => {
+            if (!/role\s*=/i.test(match)) {
+              console.log(chalk.yellow(`  🏛️ Added role="main" to content container`));
+              return match.replace(/(<(?:div|section)[^>]*?)(\s*>)/i, '$1 role="main"$2');
+            }
+            return match;
+          });
+          break;
+        }
+      }
+    }
+    
+    // Add navigation role to nav-like elements
+    const navPattern = /<(?:ul|div)([^>]*class\s*=\s*["'][^"']*(?:nav|menu|navigation)[^"']*["'][^>]*)>/gi;
+    fixed = fixed.replace(navPattern, (match, attributes) => {
+      if (!/role\s*=/i.test(match)) {
+        console.log(chalk.yellow(`  🏛️ Added role="navigation" to navigation element`));
+        return match.replace(/(<(?:ul|div)[^>]*?)(\s*>)/i, '$1 role="navigation"$2');
+      }
+      return match;
+    });
+    
+    return fixed;
+  }
+
+  // Analyze headings (no auto-fix, only suggestions)
+  async analyzeHeadings(directory = '.') {
+    console.log(chalk.blue('📑 Analyzing heading structure...'));
+    
+    const htmlFiles = await this.findHtmlFiles(directory);
+    const results = [];
+    
+    for (const file of htmlFiles) {
+      try {
+        const content = await fs.readFile(file, 'utf8');
+        const issues = this.analyzeHeadingStructure(content);
+        
+        if (issues.length > 0) {
+          console.log(chalk.cyan(`\n📁 ${file}:`));
+          issues.forEach(issue => {
+            console.log(chalk.yellow(`  ${issue.type}: ${issue.description}`));
+            if (issue.suggestion) {
+              console.log(chalk.gray(`    💡 ${issue.suggestion}`));
+            }
+          });
+        }
+        
+        results.push({ file, status: 'analyzed', issues: issues.length, suggestions: issues });
+      } 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: Analyzed heading structure in ${results.length} files`));
+    console.log(chalk.gray('💡 Heading issues require manual review and cannot be auto-fixed'));
+    return results;
+  }
+
+  analyzeHeadingStructure(content) {
+    const issues = [];
+    
+    // Extract all headings with their levels and text
+    const headingPattern = /<h([1-6])[^>]*>([\s\S]*?)<\/h[1-6]>/gi;
+    const headings = [];
+    let match;
+    
+    while ((match = headingPattern.exec(content)) !== null) {
+      const level = parseInt(match[1]);
+      const text = match[2].replace(/<[^>]*>/g, '').trim();
+      headings.push({ level, text, position: match.index });
+    }
+    
+    if (headings.length === 0) {
+      issues.push({
+        type: '📑 No headings found',
+        description: 'Page has no heading elements',
+        suggestion: 'Add heading elements (h1-h6) to structure content'
+      });
+      return issues;
+    }
+    
+    // Check for h1
+    const hasH1 = headings.some(h => h.level === 1);
+    if (!hasH1) {
+      issues.push({
+        type: '📑 Missing h1',
+        description: 'Page should have exactly one h1 element',
+        suggestion: 'Add an h1 element as the main page heading'
+      });
+    }
+    
+    // Check for multiple h1s
+    const h1Count = headings.filter(h => h.level === 1).length;
+    if (h1Count > 1) {
+      issues.push({
+        type: '📑 Multiple h1 elements',
+        description: `Found ${h1Count} h1 elements, should have only one`,
+        suggestion: 'Use only one h1 per page, use h2-h6 for subheadings'
+      });
+    }
+    
+    // Check heading order
+    for (let i = 1; i < headings.length; i++) {
+      const current = headings[i];
+      const previous = headings[i - 1];
+      
+      if (current.level > previous.level + 1) {
+        issues.push({
+          type: '📑 Heading level skip',
+          description: `Heading level jumps from h${previous.level} to h${current.level}`,
+          suggestion: `Use h${previous.level + 1} instead of h${current.level}, or add intermediate headings`
+        });
+      }
+    }
+    
+    // Check for empty headings
+    headings.forEach((heading, index) => {
+      if (!heading.text) {
+        issues.push({
+          type: '📑 Empty heading',
+          description: `Heading ${index + 1} (h${heading.level}) is empty`,
+          suggestion: 'Add descriptive text to the heading or remove it'
+        });
+      }
+    });
+    
+    return issues;
+  }
+
   async findHtmlFiles(directory) {
     const files = [];
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gbu-accessibility-package",
-  "version": "1.6.0",
+  "version": "3.0.0",
   "description": "Automated accessibility fixes for HTML files - Alt attributes, Lang attributes, Role attributes. Smart context-aware alt text generation with individual fix options and comprehensive role attribute management.",
   "main": "index.js",
   "bin": {
@@ -15,6 +15,11 @@
     "alt-only": "node cli.js --alt-only",
     "lang-only": "node cli.js --lang-only",
     "role-only": "node cli.js --role-only",
+    "forms-only": "node cli.js --forms-only",
+    "buttons-only": "node cli.js --buttons-only",
+    "links-only": "node cli.js --links-only",
+    "landmarks-only": "node cli.js --landmarks-only",
+    "headings-only": "node cli.js --headings-only",
     "cleanup-only": "node cli.js --cleanup-only",
     "no-backup": "node cli.js --no-backup",
     "cleanup-backups": "find . -name '*.backup' -type f -delete",