next-a11y 0.1.0

package/dist/cli/index.mjs

@@ -0,0 +1,2124 @@
+import {
+  DEFAULT_CONFIG,
+  DEFAULT_RULES,
+  PROVIDER_DEFAULTS,
+  PROVIDER_ENV
+} from "../chunk-PE4WYXR5.mjs";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/config/resolve.ts
+import * as fs from "fs";
+import * as path from "path";
+async function loadConfigFile(cwd) {
+  const configNames = ["a11y.config.ts", "a11y.config.js", "a11y.config.mjs"];
+  for (const name of configNames) {
+    const configPath = path.join(cwd, name);
+    if (fs.existsSync(configPath)) {
+      try {
+        if (name.endsWith(".js") || name.endsWith(".mjs")) {
+          const mod2 = await import(configPath);
+          return mod2.default ?? mod2;
+        }
+        const { createJiti } = await import("jiti").catch(() => ({ createJiti: null }));
+        if (createJiti) {
+          const jiti = createJiti(configPath);
+          const mod2 = await jiti.import(configPath);
+          return mod2.default ?? mod2;
+        }
+        const mod = await import(configPath);
+        return mod.default ?? mod;
+      } catch {
+      }
+    }
+  }
+  return {};
+}
+function resolveConfig(fileConfig, cliFlags = {}) {
+  const merged = deepMerge(DEFAULT_CONFIG, fileConfig);
+  const provider = cliFlags.provider ?? merged.provider;
+  const model = cliFlags.model ?? merged.model ?? (provider ? PROVIDER_DEFAULTS[provider] : "gpt-4.1-nano");
+  return {
+    provider,
+    model,
+    locale: merged.locale ?? "en",
+    cache: merged.cache ?? ".a11y-cache",
+    scanner: {
+      include: merged.scanner?.include ?? DEFAULT_CONFIG.scanner.include,
+      exclude: merged.scanner?.exclude ?? DEFAULT_CONFIG.scanner.exclude
+    },
+    rules: { ...DEFAULT_RULES, ...merged.rules },
+    fix: cliFlags.fix ?? false,
+    interactive: cliFlags.interactive ?? false,
+    noAi: cliFlags.noAi ?? false,
+    minScore: cliFlags.minScore
+  };
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    const val = source[key];
+    if (val === void 0) continue;
+    if (typeof val === "object" && val !== null && !Array.isArray(val) && typeof result[key] === "object" && result[key] !== null) {
+      result[key] = { ...result[key], ...val };
+    } else {
+      result[key] = val;
+    }
+  }
+  return result;
+}
+
+// src/scan/scan.ts
+import * as path4 from "path";
+import { Project } from "ts-morph";
+
+// src/scan/glob.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+async function discoverFiles(basePath, include, exclude) {
+  const absBase = path2.resolve(basePath);
+  const allFiles = [];
+  if (typeof fs2.glob === "function") {
+    for (const pattern of include) {
+      try {
+        const matches = await new Promise((resolve3, reject) => {
+          fs2.glob(
+            pattern,
+            { cwd: absBase },
+            (err, files) => {
+              if (err) reject(err);
+              else resolve3(files);
+            }
+          );
+        });
+        for (const f of matches) {
+          allFiles.push(path2.join(absBase, f));
+        }
+      } catch {
+        return fallbackGlob(absBase, include, exclude);
+      }
+    }
+  } else {
+    return fallbackGlob(absBase, include, exclude);
+  }
+  return filterExcluded(allFiles, exclude);
+}
+async function fallbackGlob(basePath, include, exclude) {
+  const allFiles = await walkDir(basePath);
+  const matched = allFiles.filter((f) => {
+    const rel = path2.relative(basePath, f);
+    return include.some((pattern) => matchGlob(rel, pattern));
+  });
+  return filterExcluded(matched, exclude);
+}
+function filterExcluded(files, exclude) {
+  if (exclude.length === 0) return files;
+  return files.filter((f) => {
+    const rel = path2.relative(path2.dirname(f), f);
+    return !exclude.some(
+      (pattern) => matchGlob(path2.basename(f), pattern) || matchGlob(rel, pattern) || matchGlob(f, pattern)
+    );
+  });
+}
+async function walkDir(dir) {
+  const results = [];
+  try {
+    const entries = await fs2.promises.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path2.join(dir, entry.name);
+      if (entry.name === "node_modules" || entry.name === ".git") continue;
+      if (entry.isDirectory()) {
+        results.push(...await walkDir(fullPath));
+      } else if (entry.isFile()) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function matchGlob(filePath, pattern) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const regex = globToRegex(pattern);
+  return regex.test(normalized);
+}
+function globToRegex(pattern) {
+  let regex = pattern.replace(/\\/g, "/");
+  regex = regex.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  regex = regex.replace(/\*\*/g, "___GLOBSTAR___");
+  regex = regex.replace(/\*/g, "[^/]*");
+  regex = regex.replace(/___GLOBSTAR___/g, ".*");
+  regex = regex.replace(/\?/g, "[^/]");
+  regex = regex.replace(/\\{([^}]+)\\}/g, (_, contents) => {
+    const alternatives = contents.split(",").map((s) => s.trim());
+    return `(${alternatives.join("|")})`;
+  });
+  return new RegExp(`^${regex}$`);
+}
+
+// src/rules/img-alt/img-alt.rule.ts
+import { SyntaxKind } from "ts-morph";
+
+// src/rules/img-alt/img-alt.classify.ts
+var MEANINGLESS_PATTERNS = [
+  /^image$/i,
+  /^photo$/i,
+  /^picture$/i,
+  /^img$/i,
+  /^banner$/i,
+  /^hero$/i,
+  /^thumbnail$/i,
+  /^untitled$/i,
+  /^placeholder$/i,
+  /^screenshot$/i,
+  /^IMG_\d+/i,
+  /^DSC_?\d+/i,
+  /^DCIM/i,
+  /^\d+$/,
+  /\.(jpg|jpeg|png|gif|webp|svg|avif)$/i
+];
+function classifyAlt(altValue, isExpression) {
+  if (altValue === void 0 || altValue === null) {
+    return "missing";
+  }
+  if (altValue === "") {
+    return "decorative";
+  }
+  if (isExpression) {
+    return "dynamic";
+  }
+  const trimmed = altValue.trim();
+  for (const pattern of MEANINGLESS_PATTERNS) {
+    if (pattern.test(trimmed)) {
+      return "meaningless";
+    }
+  }
+  const words = trimmed.split(/\s+/).filter(Boolean);
+  if (words.length < 3 && words.length > 0) {
+    if (words.length >= 2) return "valid";
+    if (MEANINGLESS_PATTERNS.some((p) => p.test(words[0]))) {
+      return "meaningless";
+    }
+  }
+  return "valid";
+}
+
+// src/rules/img-alt/img-alt.rule.ts
+var imgAltRule = {
+  id: "img-alt",
+  type: "ai",
+  scan(file) {
+    const violations = [];
+    const filePath = file.getFilePath();
+    const elements = [
+      ...file.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+      ...file.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement)
+    ];
+    for (const el of elements) {
+      const tagName = el.getTagNameNode().getText();
+      if (tagName !== "img" && tagName !== "Image") continue;
+      if (tagName === "Image" && !isNextImage(file)) continue;
+      const altAttr = el.getAttribute("alt");
+      let altValue;
+      let isExpression = false;
+      if (!altAttr) {
+        altValue = void 0;
+      } else if (altAttr.getKind() === SyntaxKind.JsxAttribute) {
+        const jsxAttr = altAttr.asKind(SyntaxKind.JsxAttribute);
+        const init = jsxAttr?.getInitializer();
+        if (!init) {
+          altValue = "";
+        } else if (init.getKind() === SyntaxKind.StringLiteral) {
+          altValue = init.asKind(SyntaxKind.StringLiteral)?.getLiteralValue() ?? "";
+        } else if (init.getKind() === SyntaxKind.JsxExpression) {
+          const expr = init.asKind(SyntaxKind.JsxExpression);
+          const exprText = expr?.getExpression()?.getText() ?? "";
+          if (exprText === '""' || exprText === "''") {
+            altValue = "";
+          } else {
+            altValue = exprText;
+            isExpression = true;
+          }
+        }
+      }
+      const classification = classifyAlt(altValue, isExpression);
+      if (classification === "missing" || classification === "meaningless") {
+        violations.push({
+          rule: "img-alt",
+          filePath,
+          line: el.getStartLineNumber(),
+          column: el.getStart() - el.getStartLinePos(),
+          element: el.getText().slice(0, 80),
+          message: classification === "missing" ? "Image is missing alt text" : `Image has meaningless alt text: "${altValue}"`,
+          fix: {
+            type: "insert-attr",
+            attribute: "alt",
+            value: async () => {
+              return `[AI-generated alt text placeholder]`;
+            }
+          }
+        });
+      }
+    }
+    return violations;
+  }
+};
+function isNextImage(file) {
+  const imports = file.getImportDeclarations();
+  return imports.some(
+    (imp) => imp.getModuleSpecifierValue() === "next/image" && (imp.getDefaultImport()?.getText() === "Image" || imp.getNamedImports().some((n) => n.getName() === "Image"))
+  );
+}
+
+// src/rules/button-label/button-label.rule.ts
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+var buttonLabelRule = {
+  id: "button-label",
+  type: "ai",
+  scan(file) {
+    const violations = [];
+    const filePath = file.getFilePath();
+    const elements = [
+      ...file.getDescendantsOfKind(SyntaxKind2.JsxOpeningElement),
+      ...file.getDescendantsOfKind(SyntaxKind2.JsxSelfClosingElement)
+    ];
+    for (const el of elements) {
+      const tagName = el.getTagNameNode().getText();
+      if (tagName !== "button") continue;
+      if (el.getAttribute("aria-label") || el.getAttribute("aria-labelledby")) {
+        continue;
+      }
+      if (el.getKind() === SyntaxKind2.JsxOpeningElement) {
+        const parent = el.getParent();
+        if (parent) {
+          const hasTextContent = parent.getDescendantsOfKind(SyntaxKind2.JsxText).some((t) => t.getText().trim().length > 0);
+          if (hasTextContent) continue;
+          const nestedElements = parent.getDescendantsOfKind(
+            SyntaxKind2.JsxOpeningElement
+          );
+          const hasAccessibleChild = nestedElements.some((nested) => {
+            const nestedTag = nested.getTagNameNode().getText();
+            return nestedTag !== "svg" && !nestedTag.endsWith("Icon") && nested.getParent()?.getDescendantsOfKind(SyntaxKind2.JsxText).some((t) => t.getText().trim().length > 0);
+          });
+          if (hasAccessibleChild) continue;
+        }
+      }
+      if (el.getKind() === SyntaxKind2.JsxSelfClosingElement) {
+      }
+      const iconName = getIconName(el);
+      violations.push({
+        rule: "button-label",
+        filePath,
+        line: el.getStartLineNumber(),
+        column: el.getStart() - el.getStartLinePos(),
+        element: el.getText().slice(0, 80),
+        message: "Button has no accessible name",
+        fix: {
+          type: "insert-attr",
+          attribute: "aria-label",
+          value: async () => {
+            if (iconName) {
+              return iconNameToLabel(iconName);
+            }
+            return "Button";
+          }
+        }
+      });
+    }
+    return violations;
+  }
+};
+function getIconName(el) {
+  const parent = el.getParent();
+  if (!parent) return void 0;
+  const selfClosingChildren = parent.getDescendantsOfKind(
+    SyntaxKind2.JsxSelfClosingElement
+  );
+  for (const child of selfClosingChildren) {
+    const tag = child.getTagNameNode().getText();
+    if (tag.endsWith("Icon") || tag === "svg") {
+      return tag;
+    }
+  }
+  const openingChildren = parent.getDescendantsOfKind(
+    SyntaxKind2.JsxOpeningElement
+  );
+  for (const child of openingChildren) {
+    const tag = child.getTagNameNode().getText();
+    if (tag.endsWith("Icon") || tag === "svg") {
+      return tag;
+    }
+  }
+  return void 0;
+}
+function iconNameToLabel(iconName) {
+  const nameMap = {
+    TrashIcon: "Delete",
+    DeleteIcon: "Delete",
+    XIcon: "Close",
+    CloseIcon: "Close",
+    MenuIcon: "Menu",
+    HamburgerIcon: "Menu",
+    SearchIcon: "Search",
+    EditIcon: "Edit",
+    PencilIcon: "Edit",
+    SettingsIcon: "Settings",
+    GearIcon: "Settings",
+    ChevronLeftIcon: "Go back",
+    ChevronRightIcon: "Go forward",
+    ArrowLeftIcon: "Go back",
+    ArrowRightIcon: "Go forward",
+    PlusIcon: "Add",
+    MinusIcon: "Remove",
+    HeartIcon: "Favorite",
+    StarIcon: "Star",
+    ShareIcon: "Share",
+    DownloadIcon: "Download",
+    UploadIcon: "Upload",
+    CopyIcon: "Copy",
+    RefreshIcon: "Refresh",
+    FilterIcon: "Filter",
+    SortIcon: "Sort",
+    ExpandIcon: "Expand",
+    CollapseIcon: "Collapse",
+    PlayIcon: "Play",
+    PauseIcon: "Pause",
+    StopIcon: "Stop",
+    MuteIcon: "Mute",
+    VolumeIcon: "Volume",
+    BellIcon: "Notifications",
+    UserIcon: "User profile",
+    LogoutIcon: "Log out",
+    LoginIcon: "Log in",
+    EyeIcon: "Show",
+    EyeOffIcon: "Hide",
+    LockIcon: "Lock",
+    UnlockIcon: "Unlock",
+    InfoIcon: "Information",
+    HelpIcon: "Help",
+    WarningIcon: "Warning",
+    CheckIcon: "Confirm",
+    SaveIcon: "Save",
+    PrintIcon: "Print",
+    HomeIcon: "Home",
+    CalendarIcon: "Calendar",
+    ClockIcon: "Clock",
+    MapIcon: "Map",
+    PhoneIcon: "Phone",
+    MailIcon: "Email",
+    SendIcon: "Send",
+    AttachIcon: "Attach",
+    LinkIcon: "Link",
+    ExternalLinkIcon: "Open in new tab",
+    MoreIcon: "More options",
+    DotsVerticalIcon: "More options",
+    DotsHorizontalIcon: "More options",
+    GridIcon: "Grid view",
+    ListIcon: "List view",
+    SunIcon: "Light mode",
+    MoonIcon: "Dark mode"
+  };
+  if (nameMap[iconName]) return nameMap[iconName];
+  const name = iconName.replace(/Icon$/, "").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+// src/rules/link-label/link-label.rule.ts
+import { SyntaxKind as SyntaxKind3 } from "ts-morph";
+var linkLabelRule = {
+  id: "link-label",
+  type: "ai",
+  scan(file) {
+    const violations = [];
+    const filePath = file.getFilePath();
+    const elements = [
+      ...file.getDescendantsOfKind(SyntaxKind3.JsxOpeningElement),
+      ...file.getDescendantsOfKind(SyntaxKind3.JsxSelfClosingElement)
+    ];
+    for (const el of elements) {
+      const tagName = el.getTagNameNode().getText();
+      if (tagName !== "a" && tagName !== "Link") continue;
+      if (tagName === "Link" && !isNextLink(file)) continue;
+      if (el.getAttribute("aria-label") || el.getAttribute("aria-labelledby")) {
+        continue;
+      }
+      if (el.getKind() === SyntaxKind3.JsxOpeningElement) {
+        const parent = el.getParent();
+        if (parent) {
+          const hasTextContent = parent.getDescendantsOfKind(SyntaxKind3.JsxText).some((t) => t.getText().trim().length > 0);
+          if (hasTextContent) continue;
+          const images = [
+            ...parent.getDescendantsOfKind(SyntaxKind3.JsxSelfClosingElement),
+            ...parent.getDescendantsOfKind(SyntaxKind3.JsxOpeningElement)
+          ];
+          const hasAltImage = images.some((img) => {
+            const imgTag = img.getTagNameNode().getText();
+            if (imgTag !== "img" && imgTag !== "Image") return false;
+            const alt = img.getAttribute("alt");
+            if (!alt) return false;
+            const jsxAttr = alt.asKind(SyntaxKind3.JsxAttribute);
+            const init = jsxAttr?.getInitializer();
+            if (!init) return false;
+            if (init.getKind() === SyntaxKind3.StringLiteral) {
+              return (init.asKind(SyntaxKind3.StringLiteral)?.getLiteralValue() ?? "").length > 0;
+            }
+            return true;
+          });
+          if (hasAltImage) continue;
+        }
+      }
+      const iconName = getIconName2(el);
+      violations.push({
+        rule: "link-label",
+        filePath,
+        line: el.getStartLineNumber(),
+        column: el.getStart() - el.getStartLinePos(),
+        element: el.getText().slice(0, 80),
+        message: "Link has no accessible name",
+        fix: {
+          type: "insert-attr",
+          attribute: "aria-label",
+          value: async () => {
+            if (iconName) {
+              return iconNameToLabel2(iconName);
+            }
+            return "Link";
+          }
+        }
+      });
+    }
+    return violations;
+  }
+};
+function isNextLink(file) {
+  const imports = file.getImportDeclarations();
+  return imports.some(
+    (imp) => imp.getModuleSpecifierValue() === "next/link" && (imp.getDefaultImport()?.getText() === "Link" || imp.getNamedImports().some((n) => n.getName() === "Link"))
+  );
+}
+function getIconName2(el) {
+  const parent = el.getParent();
+  if (!parent) return void 0;
+  const selfClosingChildren = parent.getDescendantsOfKind(
+    SyntaxKind3.JsxSelfClosingElement
+  );
+  for (const child of selfClosingChildren) {
+    const tag = child.getTagNameNode().getText();
+    if (tag.endsWith("Icon") || tag === "svg") {
+      return tag;
+    }
+  }
+  return void 0;
+}
+function iconNameToLabel2(iconName) {
+  const name = iconName.replace(/Icon$/, "").replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase();
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+
+// src/rules/input-label/input-label.rule.ts
+import { SyntaxKind as SyntaxKind4 } from "ts-morph";
+var INPUT_TAGS = ["input", "select", "textarea"];
+var inputLabelRule = {
+  id: "input-label",
+  type: "ai",
+  scan(file) {
+    const violations = [];
+    const filePath = file.getFilePath();
+    const elements = [
+      ...file.getDescendantsOfKind(SyntaxKind4.JsxOpeningElement),
+      ...file.getDescendantsOfKind(SyntaxKind4.JsxSelfClosingElement)
+    ];
+    for (const el of elements) {
+      const tagName = el.getTagNameNode().getText();
+      if (!INPUT_TAGS.includes(tagName)) continue;
+      const typeAttr = el.getAttribute("type");
+      if (typeAttr) {
+        const jsxAttr = typeAttr.asKind(SyntaxKind4.JsxAttribute);
+        const init = jsxAttr?.getInitializer();
+        if (init?.getKind() === SyntaxKind4.StringLiteral) {
+          const typeValue = init.asKind(SyntaxKind4.StringLiteral)?.getLiteralValue();
+          if (typeValue === "hidden") continue;
+        }
+      }
+      if (el.getAttribute("aria-label") || el.getAttribute("aria-labelledby")) {
+        continue;
+      }
+      const idAttr = el.getAttribute("id");
+      if (idAttr) {
+        const jsxAttr = idAttr.asKind(SyntaxKind4.JsxAttribute);
+        const init = jsxAttr?.getInitializer();
+        if (init?.getKind() === SyntaxKind4.StringLiteral) {
+          const idValue = init.asKind(SyntaxKind4.StringLiteral)?.getLiteralValue();
+          if (idValue && hasLabelFor(file, idValue)) continue;
+        }
+      }
+      if (isWrappedInLabel(el)) continue;
+      const placeholder = getStringAttribute(el, "placeholder");
+      const name = getStringAttribute(el, "name");
+      violations.push({
+        rule: "input-label",
+        filePath,
+        line: el.getStartLineNumber(),
+        column: el.getStart() - el.getStartLinePos(),
+        element: el.getText().slice(0, 80),
+        message: `<${tagName}> is missing an associated label`,
+        fix: {
+          type: "insert-attr",
+          attribute: "aria-label",
+          value: async () => {
+            if (placeholder) return placeholder;
+            if (name) {
+              return name.replace(/([a-z])([A-Z])/g, "$1 $2").replace(/[_-]/g, " ").replace(/^\w/, (c) => c.toUpperCase());
+            }
+            return tagName === "select" ? "Select option" : tagName === "textarea" ? "Text input" : "Input";
+          }
+        }
+      });
+    }
+    return violations;
+  }
+};
+function hasLabelFor(file, id) {
+  const allElements = [
+    ...file.getDescendantsOfKind(SyntaxKind4.JsxOpeningElement),
+    ...file.getDescendantsOfKind(SyntaxKind4.JsxSelfClosingElement)
+  ];
+  return allElements.some((el) => {
+    if (el.getTagNameNode().getText() !== "label") return false;
+    const htmlFor = el.getAttribute("htmlFor");
+    if (!htmlFor) return false;
+    const jsxAttr = htmlFor.asKind(SyntaxKind4.JsxAttribute);
+    const init = jsxAttr?.getInitializer();
+    if (init?.getKind() === SyntaxKind4.StringLiteral) {
+      return init.asKind(SyntaxKind4.StringLiteral)?.getLiteralValue() === id;
+    }
+    return false;
+  });
+}
+function isWrappedInLabel(el) {
+  let current = el.getParent();
+  while (current) {
+    if (current.getKind() === SyntaxKind4.JsxElement) {
+      const opening = current.getFirstChildByKind(SyntaxKind4.JsxOpeningElement);
+      if (opening?.getTagNameNode().getText() === "label") return true;
+    }
+    current = current.getParent();
+  }
+  return false;
+}
+function getStringAttribute(el, name) {
+  const attr = el.getAttribute(name);
+  if (!attr) return void 0;
+  const jsxAttr = attr.asKind(SyntaxKind4.JsxAttribute);
+  const init = jsxAttr?.getInitializer();
+  if (init?.getKind() === SyntaxKind4.StringLiteral) {
+    return init.asKind(SyntaxKind4.StringLiteral)?.getLiteralValue();
+  }
+  return void 0;
+}
+
+// src/rules/no-positive-tabindex/no-positive-tabindex.rule.ts
+import { SyntaxKind as SyntaxKind5 } from "ts-morph";
+var noPositiveTabindexRule = {
+  id: "no-positive-tabindex",
+  type: "deterministic",
+  scan(file) {
+    const violations = [];
+    const filePath = file.getFilePath();
+    const jsxAttributes = file.getDescendantsOfKind(SyntaxKind5.JsxAttribute);
+    for (const attr of jsxAttributes) {
+      const name = attr.getNameNode().getText();
+      if (name !== "tabIndex") continue;
+      const initializer = attr.getInitializer();
+      if (!initializer) continue;
+      if (initializer.isKind(SyntaxKind5.JsxExpression)) {
+        const expression = initializer.getExpression();
+        if (!expression) continue;
+        if (expression.isKind(SyntaxKind5.NumericLiteral)) {
+          const value = expression.getLiteralValue();
+          if (value > 0) {
+            const jsxElement = attr.getFirstAncestorByKind(SyntaxKind5.JsxOpeningElement) ?? attr.getFirstAncestorByKind(SyntaxKind5.JsxSelfClosingElement);
+            const tagName = jsxElement ? jsxElement.getTagNameNode().getText() : "unknown";
+            violations.push({
+              rule: "no-positive-tabindex",
+              filePath,
+              line: attr.getStartLineNumber(),
+              column: attr.getStart() - attr.getStartLinePos() + 1,
+              element: tagName,
+              message: `Avoid using positive tabIndex value (${value}). Use tabIndex={0} or tabIndex={-1} instead.`,
+              fix: {
+                type: "replace-attr",
+                attribute: "tabIndex",
+                value: "0"
+              }
+            });
+          }
+        }
+      }
+    }
+    return violations;
+  }
+};
+
+// src/rules/button-type/button-type.rule.ts
+import { SyntaxKind as SyntaxKind6 } from "ts-morph";
+var buttonTypeRule = {
+  id: "button-type",
+  type: "deterministic",
+  scan(file) {
+    const violations = [];
+    const filePath = file.getFilePath();
+    const openingElements = file.getDescendantsOfKind(
+      SyntaxKind6.JsxOpeningElement
+    );
+    for (const element of openingElements) {
+      const tagName = element.getTagNameNode().getText();
+      if (tagName !== "button") continue;
+      const typeAttr = element.getAttributes().find(
+        (attr) => attr.isKind(SyntaxKind6.JsxAttribute) && attr.getNameNode().getText() === "type"
+      );
+      if (typeAttr) continue;
+      const { line, column } = file.getLineAndColumnAtPos(element.getStart());
+      violations.push({
+        rule: "button-type",
+        filePath,
+        line,
+        column,
+        element: "<button>",
+        message: 'Native <button> elements should have an explicit "type" attribute to avoid unexpected form submissions.',
+        fix: {
+          type: "insert-attr",
+          attribute: "type",
+          value: "button"
+        }
+      });
+    }
+    const selfClosingElements = file.getDescendantsOfKind(
+      SyntaxKind6.JsxSelfClosingElement
+    );
+    for (const element of selfClosingElements) {
+      const tagName = element.getTagNameNode().getText();
+      if (tagName !== "button" && tagName[0] === tagName[0].toUpperCase()) {
+        const hasTypeAttr = element.getAttributes().some(
+          (attr) => attr.isKind(SyntaxKind6.JsxAttribute) && attr.getNameNode().getText() === "type"
+        );
+        if (!hasTypeAttr && /button/i.test(tagName)) {
+          const { line: line2, column: column2 } = file.getLineAndColumnAtPos(
+            element.getStart()
+          );
+          violations.push({
+            rule: "button-type",
+            filePath,
+            line: line2,
+            column: column2,
+            element: `<${tagName}>`,
+            message: `Custom component <${tagName}> may render a <button> without an explicit "type" attribute. Consider passing type="button".`
+          });
+        }
+        continue;
+      }
+      if (tagName !== "button") continue;
+      const typeAttr = element.getAttributes().find(
+        (attr) => attr.isKind(SyntaxKind6.JsxAttribute) && attr.getNameNode().getText() === "type"
+      );
+      if (typeAttr) continue;
+      const { line, column } = file.getLineAndColumnAtPos(element.getStart());
+      violations.push({
+        rule: "button-type",
+        filePath,
+        line,
+        column,
+        element: "<button>",
+        message: 'Native <button> elements should have an explicit "type" attribute to avoid unexpected form submissions.',
+        fix: {
+          type: "insert-attr",
+          attribute: "type",
+          value: "button"
+        }
+      });
+    }
+    for (const element of openingElements) {
+      const tagName = element.getTagNameNode().getText();
+      if (tagName[0] !== tagName[0].toUpperCase()) continue;
+      if (!/button/i.test(tagName)) continue;
+      const hasTypeAttr = element.getAttributes().some(
+        (attr) => attr.isKind(SyntaxKind6.JsxAttribute) && attr.getNameNode().getText() === "type"
+      );
+      if (!hasTypeAttr) {
+        const { line, column } = file.getLineAndColumnAtPos(
+          element.getStart()
+        );
+        violations.push({
+          rule: "button-type",
+          filePath,
+          line,
+          column,
+          element: `<${tagName}>`,
+          message: `Custom component <${tagName}> may render a <button> without an explicit "type" attribute. Consider passing type="button".`
+        });
+      }
+    }
+    return violations;
+  }
+};
+
+// src/rules/link-noopener/link-noopener.rule.ts
+import { SyntaxKind as SyntaxKind7 } from "ts-morph";
+function getAttributeValue(element, name) {
+  const attr = element.getAttribute(name);
+  if (!attr || attr.getKind() !== SyntaxKind7.JsxAttribute) return void 0;
+  const init = attr.getInitializer();
+  if (!init) return void 0;
+  if (init.getKind() === SyntaxKind7.StringLiteral) {
+    return init.getLiteralValue();
+  }
+  return void 0;
+}
+function isNextLinkImported(file) {
+  const importDecls = file.getImportDeclarations();
+  return importDecls.some(
+    (decl) => decl.getModuleSpecifierValue() === "next/link"
+  );
+}
+function checkElement(element, file) {
+  const tagName = element.getTagNameNode().getText();
+  if (tagName !== "a" && tagName !== "Link") return null;
+  if (tagName === "Link" && !isNextLinkImported(file)) return null;
+  const targetValue = getAttributeValue(element, "target");
+  if (targetValue !== "_blank") return null;
+  const relValue = getAttributeValue(element, "rel");
+  const hasNoopener = relValue?.includes("noopener") ?? false;
+  const hasNoreferrer = relValue?.includes("noreferrer") ?? false;
+  if (hasNoopener && hasNoreferrer) return null;
+  const fixType = relValue === void 0 ? "insert-attr" : "replace-attr";
+  const fix = {
+    type: fixType,
+    attribute: "rel",
+    value: "noopener noreferrer"
+  };
+  const line = element.getStartLineNumber();
+  const column = element.getStartLinePos() + 1;
+  return {
+    rule: "link-noopener",
+    filePath: file.getFilePath(),
+    line,
+    column,
+    element: element.getText(),
+    message: `<${tagName} target="_blank"> is missing rel="noopener noreferrer". This is a security risk.`,
+    fix
+  };
+}
+var linkNoopenerRule = {
+  id: "link-noopener",
+  type: "deterministic",
+  scan(file) {
+    const violations = [];
+    const openingElements = file.getDescendantsOfKind(
+      SyntaxKind7.JsxOpeningElement
+    );
+    for (const el of openingElements) {
+      const violation = checkElement(el, file);
+      if (violation) violations.push(violation);
+    }
+    const selfClosingElements = file.getDescendantsOfKind(
+      SyntaxKind7.JsxSelfClosingElement
+    );
+    for (const el of selfClosingElements) {
+      const violation = checkElement(el, file);
+      if (violation) violations.push(violation);
+    }
+    return violations;
+  }
+};
+
+// src/rules/emoji-alt/emoji-alt.rule.ts
+import { SyntaxKind as SyntaxKind8 } from "ts-morph";
+
+// src/rules/emoji-alt/emoji-names.ts
+var EMOJI_NAMES = {
+  // Smileys & people
+  "\u{1F600}": "grinning face",
+  "\u{1F601}": "beaming face with smiling eyes",
+  "\u{1F602}": "face with tears of joy",
+  "\u{1F603}": "grinning face with big eyes",
+  "\u{1F604}": "grinning face with smiling eyes",
+  "\u{1F605}": "grinning face with sweat",
+  "\u{1F606}": "grinning squinting face",
+  "\u{1F609}": "winking face",
+  "\u{1F60A}": "smiling face with smiling eyes",
+  "\u{1F60D}": "smiling face with heart-eyes",
+  "\u{1F60E}": "smiling face with sunglasses",
+  "\u{1F60F}": "smirking face",
+  "\u{1F612}": "unamused face",
+  "\u{1F614}": "pensive face",
+  "\u{1F618}": "face blowing a kiss",
+  "\u{1F621}": "pouting face",
+  "\u{1F622}": "crying face",
+  "\u{1F62D}": "loudly crying face",
+  "\u{1F62E}": "face with open mouth",
+  "\u{1F631}": "face screaming in fear",
+  "\u{1F633}": "flushed face",
+  "\u{1F634}": "sleeping face",
+  "\u{1F637}": "face with medical mask",
+  "\u{1F914}": "thinking face",
+  "\u{1F923}": "rolling on the floor laughing",
+  "\u{1F929}": "star-struck",
+  "\u{1F970}": "smiling face with hearts",
+  "\u{1F973}": "partying face",
+  // Hands & gestures
+  "\u{1F44D}": "thumbs up",
+  "\u{1F44E}": "thumbs down",
+  "\u{1F44F}": "clapping hands",
+  "\u{1F44B}": "waving hand",
+  "\u{1F4AA}": "flexed biceps",
+  "\u{1F64F}": "folded hands",
+  "\u270C\uFE0F": "victory hand",
+  "\u{1F91D}": "handshake",
+  // Hearts & love
+  "\u2764\uFE0F": "red heart",
+  "\u{1F494}": "broken heart",
+  "\u{1F495}": "two hearts",
+  "\u{1F496}": "sparkling heart",
+  "\u{1F499}": "blue heart",
+  "\u{1F49A}": "green heart",
+  "\u{1F49B}": "yellow heart",
+  "\u{1F49C}": "purple heart",
+  "\u{1F5A4}": "black heart",
+  "\u{1F90D}": "white heart",
+  "\u{1F9E1}": "orange heart",
+  // Nature & animals
+  "\u{1F525}": "fire",
+  "\u2B50": "star",
+  "\u{1F31F}": "glowing star",
+  "\u2600\uFE0F": "sun",
+  "\u{1F308}": "rainbow",
+  "\u26A1": "high voltage",
+  "\u{1F4A7}": "droplet",
+  "\u2744\uFE0F": "snowflake",
+  "\u{1F33A}": "hibiscus",
+  "\u{1F339}": "rose",
+  "\u{1F335}": "cactus",
+  "\u{1F343}": "leaf fluttering in wind",
+  "\u{1F436}": "dog face",
+  "\u{1F431}": "cat face",
+  "\u{1F98B}": "butterfly",
+  // Objects & symbols
+  "\u{1F680}": "rocket",
+  "\u2705": "check mark",
+  "\u274C": "cross mark",
+  "\u26A0\uFE0F": "warning",
+  "\u{1F6A8}": "police car light",
+  "\u{1F4A1}": "light bulb",
+  "\u{1F389}": "party popper",
+  "\u{1F381}": "wrapped gift",
+  "\u{1F3AF}": "bullseye",
+  "\u{1F3C6}": "trophy",
+  "\u{1F4E2}": "loudspeaker",
+  "\u{1F514}": "bell",
+  "\u{1F4CC}": "pushpin",
+  "\u{1F4DD}": "memo",
+  "\u{1F4DA}": "books",
+  "\u{1F4BB}": "laptop",
+  "\u{1F4F1}": "mobile phone",
+  "\u{1F510}": "locked with key",
+  "\u{1F512}": "locked",
+  "\u{1F513}": "unlocked",
+  "\u{1F504}": "counterclockwise arrows",
+  "\u{1F4B0}": "money bag",
+  "\u{1F3E0}": "house",
+  "\u{1F4E7}": "e-mail",
+  // Food & drink
+  "\u2615": "hot beverage",
+  "\u{1F355}": "pizza",
+  "\u{1F382}": "birthday cake",
+  "\u{1F37A}": "beer mug",
+  "\u{1F377}": "wine glass",
+  // Miscellaneous symbols
+  "\u2728": "sparkles",
+  "\u{1F4AF}": "hundred points",
+  "\u{1F44C}": "OK hand",
+  "\u270D\uFE0F": "writing hand",
+  "\u{1F4A5}": "collision",
+  "\u{1F4AB}": "dizzy",
+  "\u{1F440}": "eyes",
+  "\u{1F4AC}": "speech balloon",
+  "\u23F0": "alarm clock",
+  "\u{1F30D}": "globe showing Europe-Africa",
+  "\u{1F30E}": "globe showing Americas",
+  "\u{1F30F}": "globe showing Asia-Australia"
+};
+function getEmojiName(emoji) {
+  return EMOJI_NAMES[emoji] ?? "emoji";
+}
+
+// src/rules/emoji-alt/emoji-alt.rule.ts
+var EMOJI_REGEX = /(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F)(?:\u200D(?:\p{Emoji_Presentation}|\p{Emoji}\uFE0F))*/gu;
+function isWrappedInAccessibleSpan(node) {
+  const parent = node.getParent();
+  if (!parent) return false;
+  if (parent.getKind() !== SyntaxKind8.JsxElement) return false;
+  const jsxElement = parent;
+  const openingElement = jsxElement.getChildrenOfKind(SyntaxKind8.JsxOpeningElement)[0];
+  if (!openingElement) return false;
+  const tagName = openingElement.getTagNameNode().getText();
+  if (tagName !== "span") return false;
+  const attributes = openingElement.getAttributes();
+  let hasRoleImg = false;
+  let hasAriaLabel = false;
+  for (const attr of attributes) {
+    if (attr.getKind() !== SyntaxKind8.JsxAttribute) continue;
+    const jsxAttr = attr;
+    const name = jsxAttr.getNameNode().getText();
+    if (name === "role") {
+      const init = jsxAttr.getInitializer();
+      if (init && init.getKind() === SyntaxKind8.StringLiteral) {
+        const value = init.getLiteralValue();
+        if (value === "img") hasRoleImg = true;
+      }
+    }
+    if (name === "aria-label") {
+      const init = jsxAttr.getInitializer();
+      if (init) hasAriaLabel = true;
+    }
+  }
+  return hasRoleImg && hasAriaLabel;
+}
+var emojiAltRule = {
+  id: "emoji-alt",
+  type: "deterministic",
+  scan(file) {
+    const violations = [];
+    const filePath = file.getFilePath();
+    const jsxTextNodes = file.getDescendantsOfKind(SyntaxKind8.JsxText);
+    for (const textNode of jsxTextNodes) {
+      const text = textNode.getText();
+      EMOJI_REGEX.lastIndex = 0;
+      let match;
+      while ((match = EMOJI_REGEX.exec(text)) !== null) {
+        const emoji = match[0];
+        if (isWrappedInAccessibleSpan(textNode)) continue;
+        const nodeStart = textNode.getStart();
+        const sourceFile = textNode.getSourceFile();
+        const emojiPos = nodeStart + match.index;
+        const lineAndCol = sourceFile.getLineAndColumnAtPos(emojiPos);
+        const emojiName = getEmojiName(emoji);
+        violations.push({
+          rule: "emoji-alt",
+          filePath,
+          line: lineAndCol.line,
+          column: lineAndCol.column,
+          element: emoji,
+          message: `Emoji "${emoji}" is missing accessible labeling. Wrap it in <span role="img" aria-label="${emojiName}">${emoji}</span> so screen readers can announce its meaning.`,
+          fix: {
+            type: "wrap-element",
+            value: emojiName
+          }
+        });
+      }
+    }
+    return violations;
+  }
+};
+
+// src/rules/html-lang/html-lang.rule.ts
+import { SyntaxKind as SyntaxKind9 } from "ts-morph";
+var htmlLangRule = {
+  id: "html-lang",
+  type: "deterministic",
+  scan(file) {
+    const filePath = file.getFilePath();
+    if (!isRootLayoutOrDocument(filePath)) {
+      return [];
+    }
+    const violations = [];
+    const openingElements = file.getDescendantsOfKind(
+      SyntaxKind9.JsxOpeningElement
+    );
+    for (const el of openingElements) {
+      const tagName = el.getTagNameNode().getText();
+      if (tagName === "html") {
+        const langAttr = el.getAttributes().find(
+          (attr) => attr.getKind() === SyntaxKind9.JsxAttribute && attr.getChildAtIndex(0).getText() === "lang"
+        );
+        if (!langAttr) {
+          violations.push({
+            rule: "html-lang",
+            filePath,
+            line: el.getStartLineNumber(),
+            column: el.getStartLinePos() + 1,
+            element: "<html>",
+            message: "The <html> element must have a `lang` attribute for accessibility (WCAG 3.1.1).",
+            fix: {
+              type: "insert-attr",
+              attribute: "lang",
+              value: "en"
+            }
+          });
+        }
+      }
+    }
+    const selfClosingElements = file.getDescendantsOfKind(
+      SyntaxKind9.JsxSelfClosingElement
+    );
+    for (const el of selfClosingElements) {
+      const tagName = el.getTagNameNode().getText();
+      if (tagName === "html") {
+        const langAttr = el.getAttributes().find(
+          (attr) => attr.getKind() === SyntaxKind9.JsxAttribute && attr.getChildAtIndex(0).getText() === "lang"
+        );
+        if (!langAttr) {
+          violations.push({
+            rule: "html-lang",
+            filePath,
+            line: el.getStartLineNumber(),
+            column: el.getStartLinePos() + 1,
+            element: "<html />",
+            message: "The <html> element must have a `lang` attribute for accessibility (WCAG 3.1.1).",
+            fix: {
+              type: "insert-attr",
+              attribute: "lang",
+              value: "en"
+            }
+          });
+        }
+      }
+    }
+    return violations;
+  }
+};
+function isRootLayoutOrDocument(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return normalized.includes("layout") || normalized.includes("_document");
+}
+
+// src/rules/heading-order/heading-order.rule.ts
+import { SyntaxKind as SyntaxKind10 } from "ts-morph";
+var HEADING_TAGS = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+function headingLevel(tag) {
+  return Number(tag[1]);
+}
+var headingOrderRule = {
+  id: "heading-order",
+  type: "detect",
+  scan(file) {
+    const violations = [];
+    const filePath = file.getFilePath();
+    const headings = [];
+    const openingElements = file.getDescendantsOfKind(
+      SyntaxKind10.JsxOpeningElement
+    );
+    for (const element of openingElements) {
+      const tagName = element.getTagNameNode().getText();
+      if (!HEADING_TAGS.has(tagName)) continue;
+      const { line, column } = file.getLineAndColumnAtPos(element.getStart());
+      headings.push({ tag: tagName, line, column });
+    }
+    const selfClosingElements = file.getDescendantsOfKind(
+      SyntaxKind10.JsxSelfClosingElement
+    );
+    for (const element of selfClosingElements) {
+      const tagName = element.getTagNameNode().getText();
+      if (!HEADING_TAGS.has(tagName)) continue;
+      const { line, column } = file.getLineAndColumnAtPos(element.getStart());
+      headings.push({ tag: tagName, line, column });
+    }
+    headings.sort((a, b) => a.line - b.line || a.column - b.column);
+    for (let i = 1; i < headings.length; i++) {
+      const prev = headings[i - 1];
+      const curr = headings[i];
+      const prevLevel = headingLevel(prev.tag);
+      const currLevel = headingLevel(curr.tag);
+      if (currLevel > prevLevel + 1) {
+        const expectedTag = `h${prevLevel + 1}`;
+        violations.push({
+          rule: "heading-order",
+          filePath,
+          line: curr.line,
+          column: curr.column,
+          element: `<${curr.tag}>`,
+          message: `Heading level skipped: expected ${expectedTag} but found ${curr.tag}`
+        });
+      }
+    }
+    return violations;
+  }
+};
+
+// src/rules/no-div-interactive/no-div-interactive.rule.ts
+import { SyntaxKind as SyntaxKind11 } from "ts-morph";
+var INTERACTIVE_TAGS = ["div", "span"];
+function hasAttribute(element, name) {
+  return element.getAttributes().some(
+    (attr) => attr.isKind(SyntaxKind11.JsxAttribute) && attr.getNameNode().getText() === name
+  );
+}
+var noDivInteractiveRule = {
+  id: "no-div-interactive",
+  type: "detect",
+  scan(file) {
+    const violations = [];
+    const filePath = file.getFilePath();
+    const openingElements = file.getDescendantsOfKind(
+      SyntaxKind11.JsxOpeningElement
+    );
+    for (const element of openingElements) {
+      const tagName = element.getTagNameNode().getText();
+      if (!INTERACTIVE_TAGS.includes(tagName)) continue;
+      if (!hasAttribute(element, "onClick")) continue;
+      if (hasAttribute(element, "role") && hasAttribute(element, "tabIndex")) continue;
+      const { line, column } = file.getLineAndColumnAtPos(element.getStart());
+      violations.push({
+        rule: "no-div-interactive",
+        filePath,
+        line,
+        column,
+        element: `<${tagName}>`,
+        message: "Interactive <div> should be a <button> or have role and tabIndex"
+      });
+    }
+    const selfClosingElements = file.getDescendantsOfKind(
+      SyntaxKind11.JsxSelfClosingElement
+    );
+    for (const element of selfClosingElements) {
+      const tagName = element.getTagNameNode().getText();
+      if (!INTERACTIVE_TAGS.includes(tagName)) continue;
+      if (!hasAttribute(element, "onClick")) continue;
+      if (hasAttribute(element, "role") && hasAttribute(element, "tabIndex")) continue;
+      const { line, column } = file.getLineAndColumnAtPos(element.getStart());
+      violations.push({
+        rule: "no-div-interactive",
+        filePath,
+        line,
+        column,
+        element: `<${tagName}>`,
+        message: "Interactive <div> should be a <button> or have role and tabIndex"
+      });
+    }
+    return violations;
+  }
+};
+
+// src/rules/next-metadata-title/next-metadata-title.rule.ts
+import { SyntaxKind as SyntaxKind12 } from "ts-morph";
+var PAGE_FILE_PATTERN = /\bpage\.(tsx|jsx|ts|js)$/;
+var nextMetadataTitleRule = {
+  id: "next-metadata-title",
+  type: "deterministic",
+  scan(file) {
+    const filePath = file.getFilePath();
+    if (!PAGE_FILE_PATTERN.test(filePath)) {
+      return [];
+    }
+    const variableStatements = file.getDescendantsOfKind(
+      SyntaxKind12.VariableStatement
+    );
+    for (const stmt of variableStatements) {
+      const hasExport = stmt.getModifiers().some(
+        (mod) => mod.getKind() === SyntaxKind12.ExportKeyword
+      );
+      if (!hasExport) continue;
+      const declarations = stmt.getDeclarationList().getDeclarations();
+      for (const decl of declarations) {
+        if (decl.getName() !== "metadata") continue;
+        const initializer = decl.getInitializer();
+        if (!initializer) continue;
+        if (initializer.isKind(SyntaxKind12.ObjectLiteralExpression)) {
+          const hasTitleProp = initializer.getProperties().some(
+            (prop) => prop.isKind(SyntaxKind12.PropertyAssignment) && prop.getNameNode().getText() === "title"
+          );
+          if (hasTitleProp) {
+            return [];
+          }
+        }
+      }
+    }
+    const functionDeclarations = file.getDescendantsOfKind(
+      SyntaxKind12.FunctionDeclaration
+    );
+    for (const func of functionDeclarations) {
+      if (func.getName() !== "generateMetadata") continue;
+      const hasExport = func.getModifiers().some(
+        (mod) => mod.getKind() === SyntaxKind12.ExportKeyword
+      );
+      if (hasExport) {
+        return [];
+      }
+    }
+    return [
+      {
+        rule: "next-metadata-title",
+        filePath,
+        line: 1,
+        column: 1,
+        element: "page",
+        message: "Page is missing metadata.title \u2014 Next.js route announcer will be silent"
+      }
+    ];
+  }
+};
+
+// src/rules/next-image-sizes/next-image-sizes.rule.ts
+import { SyntaxKind as SyntaxKind13 } from "ts-morph";
+function isNextImageImported(file) {
+  const importDecls = file.getImportDeclarations();
+  return importDecls.some(
+    (decl) => decl.getModuleSpecifierValue() === "next/image"
+  );
+}
+function hasBooleanAttribute(element, name) {
+  const attrs = element.getAttributes();
+  for (const attr of attrs) {
+    if (!attr.isKind(SyntaxKind13.JsxAttribute)) continue;
+    if (attr.getNameNode().getText() !== name) continue;
+    const init = attr.getInitializer();
+    if (!init) return true;
+    if (init.isKind(SyntaxKind13.JsxExpression)) {
+      const expr = init.getExpression();
+      if (expr && expr.getText() === "true") return true;
+    }
+    return false;
+  }
+  return false;
+}
+function hasAttribute2(element, name) {
+  return element.getAttributes().some(
+    (attr) => attr.isKind(SyntaxKind13.JsxAttribute) && attr.getNameNode().getText() === name
+  );
+}
+function checkElement2(element, file) {
+  const tagName = element.getTagNameNode().getText();
+  if (tagName !== "Image") return null;
+  if (!hasBooleanAttribute(element, "fill")) return null;
+  if (hasAttribute2(element, "sizes")) return null;
+  const { line, column } = file.getLineAndColumnAtPos(element.getStart());
+  return {
+    rule: "next-image-sizes",
+    filePath: file.getFilePath(),
+    line,
+    column,
+    element: "<Image>",
+    message: "<Image fill> without sizes prop loads full-width image on all viewports"
+  };
+}
+var nextImageSizesRule = {
+  id: "next-image-sizes",
+  type: "deterministic",
+  scan(file) {
+    if (!isNextImageImported(file)) return [];
+    const violations = [];
+    const openingElements = file.getDescendantsOfKind(
+      SyntaxKind13.JsxOpeningElement
+    );
+    for (const el of openingElements) {
+      const violation = checkElement2(el, file);
+      if (violation) violations.push(violation);
+    }
+    const selfClosingElements = file.getDescendantsOfKind(
+      SyntaxKind13.JsxSelfClosingElement
+    );
+    for (const el of selfClosingElements) {
+      const violation = checkElement2(el, file);
+      if (violation) violations.push(violation);
+    }
+    return violations;
+  }
+};
+
+// src/rules/next-skip-nav/next-skip-nav.rule.ts
+import { SyntaxKind as SyntaxKind14 } from "ts-morph";
+var LAYOUT_FILE_PATTERN = /\blayout\.(tsx|jsx)$/;
+function getAttributeStringValue(element, name) {
+  const attr = element.getAttribute(name);
+  if (!attr || !attr.isKind(SyntaxKind14.JsxAttribute)) return void 0;
+  const init = attr.getInitializer();
+  if (!init) return void 0;
+  if (init.isKind(SyntaxKind14.StringLiteral)) {
+    return init.getLiteralValue();
+  }
+  return void 0;
+}
+function getJsxChildrenText(element) {
+  const parent = element.getParentIfKind(SyntaxKind14.JsxElement);
+  if (!parent) return "";
+  return parent.getJsxChildren().map((child) => child.getText()).join(" ");
+}
+var nextSkipNavRule = {
+  id: "next-skip-nav",
+  type: "deterministic",
+  scan(file) {
+    const filePath = file.getFilePath();
+    if (!LAYOUT_FILE_PATTERN.test(filePath)) {
+      return [];
+    }
+    const openingElements = file.getDescendantsOfKind(
+      SyntaxKind14.JsxOpeningElement
+    );
+    for (const el of openingElements) {
+      const tagName = el.getTagNameNode().getText();
+      if (tagName !== "a") continue;
+      const href = getAttributeStringValue(el, "href");
+      if (href === "#main-content") return [];
+      const childrenText = getJsxChildrenText(el);
+      if (/skip/i.test(childrenText)) return [];
+    }
+    const selfClosingElements = file.getDescendantsOfKind(
+      SyntaxKind14.JsxSelfClosingElement
+    );
+    for (const el of selfClosingElements) {
+      const tagName = el.getTagNameNode().getText();
+      if (tagName !== "a") continue;
+      const href = getAttributeStringValue(el, "href");
+      if (href === "#main-content") return [];
+    }
+    return [
+      {
+        rule: "next-skip-nav",
+        filePath,
+        line: 1,
+        column: 1,
+        element: "layout",
+        message: "Root layout is missing a skip navigation link"
+      }
+    ];
+  }
+};
+
+// src/rules/next-link-no-nested-a/next-link-no-nested-a.rule.ts
+import { SyntaxKind as SyntaxKind15 } from "ts-morph";
+function isNextLinkImported2(file) {
+  const importDecls = file.getImportDeclarations();
+  return importDecls.some(
+    (decl) => decl.getModuleSpecifierValue() === "next/link"
+  );
+}
+function hasNestedAnchor(linkElement) {
+  const parent = linkElement.getParentIfKind(SyntaxKind15.JsxElement);
+  if (!parent) return false;
+  const children = parent.getJsxChildren();
+  for (const child of children) {
+    if (child.isKind(SyntaxKind15.JsxElement)) {
+      const opening = child.getOpeningElement();
+      if (opening.getTagNameNode().getText() === "a") return true;
+    }
+    if (child.isKind(SyntaxKind15.JsxSelfClosingElement)) {
+      if (child.getTagNameNode().getText() === "a") return true;
+    }
+  }
+  return false;
+}
+var nextLinkNoNestedARule = {
+  id: "next-link-no-nested-a",
+  type: "deterministic",
+  scan(file) {
+    if (!isNextLinkImported2(file)) return [];
+    const violations = [];
+    const openingElements = file.getDescendantsOfKind(
+      SyntaxKind15.JsxOpeningElement
+    );
+    for (const el of openingElements) {
+      const tagName = el.getTagNameNode().getText();
+      if (tagName !== "Link") continue;
+      if (!hasNestedAnchor(el)) continue;
+      const { line, column } = file.getLineAndColumnAtPos(el.getStart());
+      violations.push({
+        rule: "next-link-no-nested-a",
+        filePath: file.getFilePath(),
+        line,
+        column,
+        element: "<Link>",
+        message: "<Link> from next/link should not contain a nested <a> element. Since Next.js 13, <Link> renders an <a> automatically.",
+        fix: {
+          type: "remove-element",
+          value: "nested-a"
+        }
+      });
+    }
+    return violations;
+  }
+};
+
+// src/rules/index.ts
+var ALL_RULES = [
+  imgAltRule,
+  buttonLabelRule,
+  linkLabelRule,
+  inputLabelRule,
+  noPositiveTabindexRule,
+  buttonTypeRule,
+  linkNoopenerRule,
+  emojiAltRule,
+  htmlLangRule,
+  headingOrderRule,
+  noDivInteractiveRule,
+  nextMetadataTitleRule,
+  nextImageSizesRule,
+  nextSkipNavRule,
+  nextLinkNoNestedARule
+];
+var RULE_MAP = new Map(
+  ALL_RULES.map((r) => [r.id, r])
+);
+function getRulesForConfig(ruleSettings, noAi) {
+  return ALL_RULES.filter((rule) => {
+    const setting = ruleSettings[rule.id];
+    if (setting === "off") return false;
+    if (noAi && rule.type === "ai") return false;
+    return true;
+  });
+}
+
+// src/scan/score.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+var WEIGHT_TABLE = {
+  "img-alt": 2,
+  "button-label": 2,
+  "link-label": 2,
+  "input-label": 3,
+  "html-lang": 5,
+  "next-metadata-title": 3,
+  "next-skip-nav": 3,
+  "next-link-no-nested-a": 2,
+  "no-positive-tabindex": 1,
+  "button-type": 1,
+  "next-image-sizes": 1,
+  "heading-order": 1,
+  "no-div-interactive": 1,
+  "emoji-alt": 0.5,
+  "link-noopener": 0.5
+};
+function computeScore(violations) {
+  let score = 100;
+  for (const v of violations) {
+    const weight = WEIGHT_TABLE[v.rule] ?? 1;
+    score -= weight;
+  }
+  return Math.max(0, Math.min(100, Math.round(score)));
+}
+function getScoreBadge(score) {
+  if (score >= 90) return { label: "Good", color: "green" };
+  if (score >= 70) return { label: "Needs work", color: "yellow" };
+  return { label: "Poor", color: "red" };
+}
+function loadPreviousScore(cacheDir) {
+  const scorePath = path3.join(cacheDir, "score.json");
+  try {
+    if (fs3.existsSync(scorePath)) {
+      const data = JSON.parse(fs3.readFileSync(scorePath, "utf-8"));
+      return data.score;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function savePreviousScore(cacheDir, score) {
+  const scorePath = path3.join(cacheDir, "score.json");
+  fs3.mkdirSync(cacheDir, { recursive: true });
+  fs3.writeFileSync(scorePath, JSON.stringify({ score, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+}
+
+// src/apply/apply.ts
+import { SyntaxKind as SyntaxKind16 } from "ts-morph";
+async function applyFix(file, violation) {
+  if (!violation.fix) return false;
+  const fix = violation.fix;
+  const value = typeof fix.value === "function" ? await fix.value() : fix.value;
+  switch (fix.type) {
+    case "insert-attr":
+      return insertAttribute(file, violation.line, fix.attribute, value);
+    case "replace-attr":
+      return replaceAttribute(file, violation.line, fix.attribute, value);
+    case "wrap-element":
+      return wrapElement(file, violation.line, value);
+    case "insert-element":
+      return insertElement(file, violation.line, value);
+    case "remove-element":
+      return removeElement(file, violation.line);
+    default:
+      return false;
+  }
+}
+function insertAttribute(file, line, attribute, value) {
+  const elements = [
+    ...file.getDescendantsOfKind(SyntaxKind16.JsxOpeningElement),
+    ...file.getDescendantsOfKind(SyntaxKind16.JsxSelfClosingElement)
+  ];
+  for (const el of elements) {
+    if (el.getStartLineNumber() === line) {
+      const existing = el.getAttribute(attribute);
+      if (!existing) {
+        el.addAttribute({ name: attribute, initializer: `"${value}"` });
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function replaceAttribute(file, line, attribute, value) {
+  const elements = [
+    ...file.getDescendantsOfKind(SyntaxKind16.JsxOpeningElement),
+    ...file.getDescendantsOfKind(SyntaxKind16.JsxSelfClosingElement)
+  ];
+  for (const el of elements) {
+    if (el.getStartLineNumber() === line) {
+      const attr = el.getAttribute(attribute);
+      if (attr && attr.getKind() === SyntaxKind16.JsxAttribute) {
+        const jsxAttr = attr.asKind(SyntaxKind16.JsxAttribute);
+        if (jsxAttr) {
+          const initializer = jsxAttr.getInitializer();
+          if (initializer) {
+            if (value.startsWith("{")) {
+              initializer.replaceWithText(value);
+            } else {
+              initializer.replaceWithText(`"${value}"`);
+            }
+            return true;
+          } else {
+            jsxAttr.setInitializer(`"${value}"`);
+            return true;
+          }
+        }
+      }
+    }
+  }
+  return false;
+}
+function wrapElement(file, line, wrapperText) {
+  const fullText = file.getFullText();
+  const lines = fullText.split("\n");
+  if (line > 0 && line <= lines.length) {
+    return true;
+  }
+  return false;
+}
+function insertElement(file, line, elementText) {
+  const fullText = file.getFullText();
+  const lines = fullText.split("\n");
+  if (line > 0 && line <= lines.length) {
+    const indent = lines[line - 1].match(/^(\s*)/)?.[1] ?? "";
+    lines.splice(line - 1, 0, `${indent}${elementText}`);
+    file.replaceWithText(lines.join("\n"));
+    return true;
+  }
+  return false;
+}
+function removeElement(file, line) {
+  const fullText = file.getFullText();
+  const lines = fullText.split("\n");
+  if (line > 0 && line <= lines.length) {
+    lines.splice(line - 1, 1);
+    file.replaceWithText(lines.join("\n"));
+    return true;
+  }
+  return false;
+}
+
+// src/scan/scan.ts
+async function scan(targetPath, config) {
+  const absPath = path4.resolve(targetPath);
+  const files = await discoverFiles(
+    absPath,
+    config.scanner.include,
+    config.scanner.exclude
+  );
+  if (files.length === 0) {
+    return {
+      violations: [],
+      filesScanned: 0,
+      elementsScanned: 0,
+      score: 100,
+      fixedCount: 0
+    };
+  }
+  const project = new Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: {
+      jsx: 4,
+      // JsxEmit.ReactJSX
+      allowJs: true,
+      noEmit: true
+    }
+  });
+  for (const filePath of files) {
+    try {
+      project.addSourceFileAtPath(filePath);
+    } catch {
+    }
+  }
+  const rules = getRulesForConfig(config.rules, config.noAi);
+  const allViolations = [];
+  let elementsScanned = 0;
+  for (const sourceFile of project.getSourceFiles()) {
+    for (const rule of rules) {
+      try {
+        const violations = rule.scan(sourceFile);
+        allViolations.push(...violations);
+      } catch {
+      }
+    }
+    elementsScanned += sourceFile.getDescendants().length;
+  }
+  let fixedCount = 0;
+  if (config.fix) {
+    for (const violation of allViolations) {
+      if (!violation.fix) continue;
+      const rule = rules.find((r) => r.id === violation.rule);
+      if (config.noAi && rule?.type === "ai") continue;
+      try {
+        const sourceFile = project.getSourceFile(violation.filePath);
+        if (!sourceFile) continue;
+        const applied = await applyFix(sourceFile, violation);
+        if (applied) fixedCount++;
+      } catch {
+      }
+    }
+    if (fixedCount > 0) {
+      await project.save();
+    }
+  }
+  const remainingViolations = config.fix ? allViolations.filter((v) => !v.fix || config.noAi && rules.find((r) => r.id === v.rule)?.type === "ai") : allViolations;
+  const score = computeScore(remainingViolations);
+  const previousScore = loadPreviousScore(config.cache);
+  savePreviousScore(config.cache, score);
+  return {
+    violations: allViolations,
+    filesScanned: files.length,
+    elementsScanned,
+    score,
+    previousScore,
+    fixedCount
+  };
+}
+
+// src/cli/format.ts
+import pc from "picocolors";
+var RULE_ICONS = {
+  "img-alt": "img",
+  "button-label": "btn",
+  "link-label": "lnk",
+  "input-label": "inp",
+  "html-lang": "lng",
+  "emoji-alt": "emj",
+  "no-positive-tabindex": "tab",
+  "button-type": "btn",
+  "link-noopener": "rel",
+  "next-metadata-title": "ttl",
+  "next-image-sizes": "img",
+  "next-link-no-nested-a": "lnk",
+  "next-skip-nav": "nav",
+  "heading-order": "hdg",
+  "no-div-interactive": "div"
+};
+function formatReport(result, fix) {
+  const lines = [];
+  lines.push("");
+  lines.push(pc.bold(`  next-a11y v0.1.0`));
+  lines.push(
+    `  Scanned ${result.filesScanned} files`
+  );
+  lines.push("");
+  const badge = getScoreBadge(result.score);
+  const colorFn = badge.color === "green" ? pc.green : badge.color === "yellow" ? pc.yellow : pc.red;
+  lines.push(
+    `  ${pc.bold("Accessibility Score:")}  ${colorFn(pc.bold(`${result.score} / 100`))}  ${colorFn(badge.label)}`
+  );
+  lines.push("");
+  if (result.violations.length === 0) {
+    lines.push(pc.green("  No accessibility issues found!"));
+    lines.push("");
+    return lines.join("\n");
+  }
+  const aiViolations = result.violations.filter(
+    (v) => ["img-alt", "button-label", "link-label", "input-label"].includes(v.rule)
+  );
+  const deterministicViolations = result.violations.filter(
+    (v) => [
+      "html-lang",
+      "emoji-alt",
+      "no-positive-tabindex",
+      "button-type",
+      "link-noopener"
+    ].includes(v.rule)
+  );
+  const nextViolations = result.violations.filter(
+    (v) => [
+      "next-metadata-title",
+      "next-image-sizes",
+      "next-link-no-nested-a",
+      "next-skip-nav"
+    ].includes(v.rule)
+  );
+  const detectOnlyViolations = result.violations.filter(
+    (v) => ["heading-order", "no-div-interactive"].includes(v.rule)
+  );
+  if (aiViolations.length > 0) {
+    lines.push(pc.bold("  AI fixes available:"));
+    formatViolationGroup(lines, aiViolations);
+    lines.push("");
+  }
+  if (deterministicViolations.length > 0) {
+    lines.push(pc.bold("  Auto fixes available:"));
+    formatViolationGroup(lines, deterministicViolations);
+    lines.push("");
+  }
+  if (nextViolations.length > 0) {
+    lines.push(pc.bold("  Next.js-specific:"));
+    formatViolationGroup(lines, nextViolations);
+    lines.push("");
+  }
+  if (detectOnlyViolations.length > 0) {
+    lines.push(pc.bold("  Warnings (manual review needed):"));
+    formatViolationGroup(lines, detectOnlyViolations);
+    lines.push("");
+  }
+  const fixable = result.violations.filter((v) => v.fix).length;
+  const warnings = result.violations.filter((v) => !v.fix).length;
+  lines.push(pc.dim("  " + "-".repeat(40)));
+  if (fix && result.fixedCount > 0) {
+    lines.push(`  ${pc.green(`${result.fixedCount} fixed`)} \xB7 ${warnings} warnings`);
+  } else {
+    lines.push(
+      `  ${fixable} fixable \xB7 ${warnings} warnings${fixable > 0 ? ` \xB7 Run ${pc.bold("--fix")} to apply` : ""}`
+    );
+  }
+  if (result.previousScore !== void 0) {
+    const delta = result.score - result.previousScore;
+    if (delta !== 0) {
+      const deltaStr = delta > 0 ? pc.green(`+${delta}`) : pc.red(`${delta}`);
+      lines.push(
+        `  Score: ${result.previousScore} -> ${result.score} (${deltaStr} pts)`
+      );
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function formatViolationGroup(lines, violations) {
+  const byRule = /* @__PURE__ */ new Map();
+  for (const v of violations) {
+    const existing = byRule.get(v.rule) ?? [];
+    existing.push(v);
+    byRule.set(v.rule, existing);
+  }
+  for (const [rule, ruleViolations] of byRule) {
+    const count = ruleViolations.length;
+    const weight = WEIGHT_TABLE[rule] ?? 1;
+    const totalPts = count * weight;
+    const icon = RULE_ICONS[rule] ?? "???";
+    lines.push(
+      `    [${icon}] ${pc.bold(String(count).padStart(2))} ${formatRuleDescription(rule)}${totalPts > 0 ? pc.dim(` -${totalPts} pts`) : ""}`
+    );
+  }
+}
+function formatRuleDescription(rule) {
+  const descriptions = {
+    "img-alt": "images missing alt text",
+    "button-label": "buttons without accessible name",
+    "link-label": "links without accessible name",
+    "input-label": "inputs without label",
+    "html-lang": "missing lang on <html>",
+    "emoji-alt": 'emoji without role="img"',
+    "no-positive-tabindex": "positive tabIndex values",
+    "button-type": "buttons without type",
+    "link-noopener": 'links target="_blank" without rel',
+    "next-metadata-title": "routes missing page title",
+    "next-image-sizes": "next/image without sizes",
+    "next-link-no-nested-a": "next/link wrapping nested <a>",
+    "next-skip-nav": "missing skip navigation link",
+    "heading-order": "heading hierarchy violations",
+    "no-div-interactive": "div used as interactive element"
+  };
+  return descriptions[rule] ?? rule;
+}
+
+// src/cli/scan-command.ts
+function registerScanCommand(program2) {
+  program2.command("scan").description("Scan files for accessibility issues").argument("<path>", "Path to scan").option("--fix", "Auto-fix issues").option("-i, --interactive", "Review each fix interactively").option("--no-ai", "Skip AI-powered fixes").option("--provider <provider>", "Override AI provider").option("--model <model>", "Override AI model").option("--min-score <score>", "Minimum score threshold (exit code 1 if below)", parseInt).action(async (targetPath, options) => {
+    const fileConfig = await loadConfigFile(process.cwd());
+    const config = resolveConfig(fileConfig, {
+      fix: options.fix,
+      interactive: options.interactive,
+      noAi: !options.ai,
+      // commander inverts --no-ai to options.ai = false
+      provider: options.provider,
+      model: options.model,
+      minScore: options.minScore
+    });
+    const result = await scan(targetPath, config);
+    console.log(formatReport(result, config.fix));
+    if (config.minScore !== void 0 && result.score < config.minScore) {
+      console.error(
+        `  Score ${result.score} is below minimum threshold ${config.minScore}`
+      );
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/init-command.ts
+import * as fs4 from "fs";
+import * as path5 from "path";
+import * as readline from "readline";
+import { execSync } from "child_process";
+import pc2 from "picocolors";
+function registerInitCommand(program2) {
+  program2.command("init").description("Initialize next-a11y configuration").action(async () => {
+    console.log(pc2.bold("\n  next-a11y v0.1.0 \u2014 Setup\n"));
+    const options = await promptInitOptions();
+    const cwd = process.cwd();
+    const hasAppDir = fs4.existsSync(path5.join(cwd, "app"));
+    const hasSrcDir = fs4.existsSync(path5.join(cwd, "src"));
+    const include = [];
+    if (hasSrcDir) include.push("src/**/*.{tsx,jsx}");
+    if (hasAppDir) include.push("app/**/*.{tsx,jsx}");
+    if (include.length === 0) include.push("**/*.{tsx,jsx}");
+    const configContent = generateConfig(options.provider, include);
+    const configPath = path5.join(cwd, "a11y.config.ts");
+    fs4.writeFileSync(configPath, configContent);
+    console.log(pc2.green("  Created a11y.config.ts"));
+    if (options.provider !== "none" && options.installDep) {
+      const pkgMap = {
+        openai: "@ai-sdk/openai",
+        anthropic: "@ai-sdk/anthropic",
+        google: "@ai-sdk/google",
+        ollama: "ollama-ai-provider"
+      };
+      const pkg = pkgMap[options.provider];
+      if (pkg) {
+        const pm = detectPackageManager(cwd);
+        const installCmd = pm === "yarn" ? `yarn add ${pkg}` : pm === "pnpm" ? `pnpm add ${pkg}` : pm === "bun" ? `bun add ${pkg}` : `npm install ${pkg}`;
+        try {
+          console.log(pc2.dim(`  Running: ${installCmd}`));
+          execSync(installCmd, { cwd, stdio: "pipe" });
+          console.log(pc2.green(`  Installed ${pkg}`));
+        } catch {
+          console.log(pc2.yellow(`  Failed to install ${pkg}. Run manually: ${installCmd}`));
+        }
+      }
+    }
+    if (options.addGitignore) {
+      const gitignorePath = path5.join(cwd, ".gitignore");
+      let content = "";
+      if (fs4.existsSync(gitignorePath)) {
+        content = fs4.readFileSync(gitignorePath, "utf-8");
+      }
+      if (!content.includes(".a11y-cache")) {
+        const newline = content.endsWith("\n") ? "" : "\n";
+        fs4.appendFileSync(gitignorePath, `${newline}.a11y-cache
+`);
+        console.log(pc2.green("  Updated .gitignore"));
+      }
+    }
+    console.log("");
+    console.log(pc2.bold("  Next steps:"));
+    if (options.provider !== "none" && options.provider !== "ollama") {
+      const envVar = PROVIDER_ENV[options.provider];
+      if (envVar) {
+        console.log(`    1. Set ${pc2.bold(envVar)} in your .env`);
+        console.log(`    2. Run: ${pc2.bold("npx next-a11y scan ./src")}`);
+      }
+    } else if (options.provider === "ollama") {
+      console.log(`    1. Ensure Ollama is running locally`);
+      console.log(`    2. Run: ${pc2.bold("npx next-a11y scan ./src")}`);
+    } else {
+      console.log(`    1. Run: ${pc2.bold("npx next-a11y scan ./src --no-ai")}`);
+    }
+    console.log("");
+  });
+}
+async function promptInitOptions() {
+  const provider = await promptSelect(
+    "Which AI provider do you want to use?",
+    [
+      { value: "openai", label: "OpenAI (gpt-4.1-nano)" },
+      { value: "google", label: "Google (gemini-2.0-flash-lite) \u2014 free tier" },
+      { value: "anthropic", label: "Anthropic (claude-haiku-4-5)" },
+      { value: "ollama", label: "Ollama (local, offline)" },
+      { value: "none", label: "None \u2014 deterministic fixes only" }
+    ]
+  );
+  let installDep = false;
+  if (provider !== "none") {
+    installDep = await promptYesNo(`Install AI SDK package now?`);
+  }
+  const addGitignore = await promptYesNo(`Add .a11y-cache to .gitignore?`);
+  return { provider, installDep, addGitignore };
+}
+function promptSelect(question, options) {
+  return new Promise((resolve3) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    console.log(`  ${pc2.bold(question)}`);
+    options.forEach((opt, i) => {
+      console.log(`    ${pc2.dim(`${i + 1}.`)} ${opt.label}`);
+    });
+    rl.question(`  Choice [1-${options.length}]: `, (answer) => {
+      rl.close();
+      const idx = parseInt(answer.trim()) - 1;
+      if (idx >= 0 && idx < options.length) {
+        resolve3(options[idx].value);
+      } else {
+        resolve3(options[0].value);
+      }
+    });
+  });
+}
+function promptYesNo(question) {
+  return new Promise((resolve3) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    rl.question(`  ${question} ${pc2.dim("[Y/n]")} `, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      resolve3(normalized !== "n" && normalized !== "no");
+    });
+  });
+}
+function detectPackageManager(cwd) {
+  if (fs4.existsSync(path5.join(cwd, "bun.lock"))) return "bun";
+  if (fs4.existsSync(path5.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs4.existsSync(path5.join(cwd, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function generateConfig(provider, include) {
+  const providerLine = provider === "none" ? "  // provider: 'openai',  // Uncomment and set when ready" : `  provider: "${provider}",`;
+  const modelMap = {
+    openai: "gpt-4.1-nano",
+    anthropic: "claude-haiku-4-5-20251001",
+    google: "gemini-2.0-flash-lite",
+    ollama: "llava"
+  };
+  const modelLine = provider !== "none" ? `
+  model: "${modelMap[provider]}",` : "";
+  return `import { defineConfig } from "next-a11y";
+
+export default defineConfig({
+${providerLine}${modelLine}
+  locale: "en",
+  cache: ".a11y-cache",
+  scanner: {
+    include: [${include.map((p) => `"${p}"`).join(", ")}],
+    exclude: ["**/*.test.*", "**/*.stories.*"],
+  },
+  rules: {
+    "img-alt": "fix",
+    "button-label": "fix",
+    "link-label": "fix",
+    "input-label": "fix",
+    "html-lang": "fix",
+    "emoji-alt": "fix",
+    "no-positive-tabindex": "fix",
+    "button-type": "fix",
+    "link-noopener": "fix",
+    "next-metadata-title": "warn",
+    "next-image-sizes": "warn",
+    "next-link-no-nested-a": "fix",
+    "next-skip-nav": "warn",
+    "heading-order": "warn",
+    "no-div-interactive": "warn",
+  },
+});
+`;
+}
+
+// src/cli/cache-command.ts
+import pc3 from "picocolors";
+
+// src/cache/fs-cache.ts
+import * as fs5 from "fs";
+import * as path6 from "path";
+import * as crypto from "crypto";
+var FsCache = class {
+  constructor(cacheDir) {
+    this.cacheDir = cacheDir;
+    this.cachePath = path6.join(cacheDir, "cache.json");
+    this.data = this.load();
+  }
+  load() {
+    try {
+      if (fs5.existsSync(this.cachePath)) {
+        return JSON.parse(fs5.readFileSync(this.cachePath, "utf-8"));
+      }
+    } catch {
+    }
+    return {};
+  }
+  save() {
+    fs5.mkdirSync(this.cacheDir, { recursive: true });
+    fs5.writeFileSync(this.cachePath, JSON.stringify(this.data, null, 2));
+  }
+  static hashContent(content) {
+    return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  }
+  get(key) {
+    return this.data[key];
+  }
+  set(key, entry) {
+    this.data[key] = entry;
+    this.save();
+  }
+  has(key) {
+    return key in this.data;
+  }
+  clear() {
+    this.data = {};
+    if (fs5.existsSync(this.cachePath)) {
+      fs5.unlinkSync(this.cachePath);
+    }
+  }
+  stats() {
+    const entries = Object.keys(this.data).length;
+    let sizeBytes = 0;
+    try {
+      if (fs5.existsSync(this.cachePath)) {
+        sizeBytes = fs5.statSync(this.cachePath).size;
+      }
+    } catch {
+    }
+    return { entries, sizeBytes };
+  }
+};
+
+// src/cli/cache-command.ts
+function registerCacheCommand(program2) {
+  const cache = program2.command("cache").description("Manage the AI result cache");
+  cache.command("stats").description("Show cache statistics").action(async () => {
+    const fileConfig = await loadConfigFile(process.cwd());
+    const config = resolveConfig(fileConfig);
+    const fsCache = new FsCache(config.cache);
+    const stats = fsCache.stats();
+    console.log(pc3.bold("\n  Cache Statistics\n"));
+    console.log(`  Entries: ${stats.entries}`);
+    console.log(
+      `  Size:    ${formatBytes(stats.sizeBytes)}`
+    );
+    console.log(`  Path:    ${config.cache}/cache.json`);
+    console.log("");
+  });
+  cache.command("clear").description("Clear the cache").action(async () => {
+    const fileConfig = await loadConfigFile(process.cwd());
+    const config = resolveConfig(fileConfig);
+    const fsCache = new FsCache(config.cache);
+    fsCache.clear();
+    console.log(pc3.green("\n  Cache cleared.\n"));
+  });
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(1024));
+  return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("next-a11y").description("AI-powered accessibility codemod for Next.js").version("0.1.0");
+registerScanCommand(program);
+registerInitCommand(program);
+registerCacheCommand(program);
+program.parse();