seo-lint-next 0.1.0

package/dist/cli.cjs

@@ -0,0 +1,1023 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/cli.ts
+var import_node_fs5 = __toESM(require("fs"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
+var import_node_process = __toESM(require("process"), 1);
+var import_parser = __toESM(require("@typescript-eslint/parser"), 1);
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_eslint = require("eslint");
+
+// src/rules/no-accidental-noindex.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+
+// src/utils/ast.ts
+var import_node_path = __toESM(require("path"), 1);
+function getNodeName(node) {
+  const typed = node;
+  if (!typed) return void 0;
+  if (typed.type === "Identifier") return typed.name;
+  if (typed.type === "Literal") return String(typed.value);
+  if (typed.type === "Property" || typed.type === "PropertyDefinition") {
+    return getNodeName(typed.key);
+  }
+  if (typed.type === "JSXIdentifier") return typed.name;
+  return void 0;
+}
+function objectProperties(node) {
+  const typed = node;
+  if (!typed || typed.type !== "ObjectExpression") return [];
+  return (typed.properties ?? []).filter((property) => property.type === "Property").map((property) => ({
+    key: getNodeName(property.key) ?? "",
+    value: property.value,
+    node: property
+  })).filter((property) => property.key.length > 0);
+}
+function getObjectProperty(node, key) {
+  return objectProperties(node).find((property) => property.key === key);
+}
+function getPathProperty(node, keys) {
+  let current = node;
+  let found;
+  for (const key of keys) {
+    found = getObjectProperty(current, key);
+    if (!found) return void 0;
+    current = found.value;
+  }
+  return found;
+}
+function getStaticString(node) {
+  const typed = node;
+  if (!typed) return void 0;
+  if (typed.type === "Literal" && typeof typed.value === "string") return typed.value;
+  if (typed.type === "TemplateLiteral") {
+    const expressions = typed.expressions ?? [];
+    const quasis = typed.quasis ?? [];
+    if (expressions.length === 0) {
+      return quasis.map((quasi) => quasi.value?.cooked ?? "").join("");
+    }
+  }
+  return void 0;
+}
+function isNonEmptyStringNode(node) {
+  const value = getStaticString(node);
+  return typeof value === "string" && value.trim().length > 0;
+}
+function findMetadataObject(program) {
+  for (const statement of program.body ?? []) {
+    if (statement.type !== "ExportNamedDeclaration") continue;
+    const declaration = statement.declaration;
+    if (!declaration || declaration.type !== "VariableDeclaration") continue;
+    for (const item of declaration.declarations ?? []) {
+      if (getNodeName(item.id) === "metadata" && item.init?.type === "ObjectExpression") {
+        return item.init;
+      }
+    }
+  }
+  return void 0;
+}
+function findGenerateMetadataReturns(program) {
+  const returns = [];
+  walk(program, (node) => {
+    if (node.type !== "ExportNamedDeclaration") return;
+    const declaration = node.declaration;
+    if (!declaration) return;
+    const isNamedFunction = declaration.type === "FunctionDeclaration" && getNodeName(declaration.id) === "generateMetadata";
+    const isVariable = declaration.type === "VariableDeclaration" && (declaration.declarations ?? []).some(
+      (item) => getNodeName(item.id) === "generateMetadata"
+    );
+    if (!isNamedFunction && !isVariable) return;
+    walk(declaration, (child) => {
+      if (child.type === "ReturnStatement" && child.argument?.type === "ObjectExpression") {
+        returns.push(child.argument);
+      }
+    });
+  });
+  return returns;
+}
+function metadataSources(program) {
+  const staticMetadata = findMetadataObject(program);
+  return [staticMetadata, ...findGenerateMetadataReturns(program)].filter(Boolean);
+}
+function hasNullishFallback(node) {
+  let found = false;
+  walk(node, (child) => {
+    if (child.type === "LogicalExpression" && child.operator === "??" && isNonEmptyStringNode(child.right)) {
+      found = true;
+    }
+  });
+  return found;
+}
+function hasDynamicInterpolation(node) {
+  const typed = node;
+  if (!typed) return false;
+  if (typed.type === "TemplateLiteral") {
+    return (typed.expressions ?? []).length > 0;
+  }
+  let found = false;
+  walk(typed, (child) => {
+    if (child.type === "Identifier" && child.name === "params") found = true;
+  });
+  return found;
+}
+function walk(node, visitor) {
+  if (!node || typeof node.type !== "string") return;
+  visitor(node);
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "parent" || key === "loc" || key === "range" || key === "tokens" || key === "comments")
+      continue;
+    if (!value) continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item && typeof item === "object" && typeof item.type === "string") {
+          walk(item, visitor);
+        }
+      }
+    } else if (typeof value === "object" && typeof value.type === "string") {
+      walk(value, visitor);
+    }
+  }
+}
+function jsxAttribute(node, name) {
+  const attributes = node.attributes ?? [];
+  return attributes.find(
+    (attribute) => attribute.type === "JSXAttribute" && getNodeName(attribute.name) === name
+  );
+}
+function jsxAttributeString(node, name) {
+  const attribute = jsxAttribute(node, name);
+  if (!attribute) return void 0;
+  const value = attribute.value;
+  if (!value) return "";
+  if (value.type === "Literal") return String(value.value);
+  if (value.type === "JSXExpressionContainer") return getStaticString(value.expression);
+  return void 0;
+}
+
+// src/utils/files.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+function findProjectRoot(start = process.cwd()) {
+  let current = import_node_path2.default.resolve(start);
+  while (current !== import_node_path2.default.dirname(current)) {
+    if (import_node_fs.default.existsSync(import_node_path2.default.join(current, "package.json"))) return current;
+    current = import_node_path2.default.dirname(current);
+  }
+  return import_node_path2.default.resolve(start);
+}
+function findAppDir(root = findProjectRoot()) {
+  const candidates = [import_node_path2.default.join(root, "app"), import_node_path2.default.join(root, "src", "app")];
+  return candidates.find((candidate) => import_node_fs.default.existsSync(candidate) && import_node_fs.default.statSync(candidate).isDirectory());
+}
+function isPageFile(filename) {
+  return /(^|\/)page\.[cm]?[jt]sx?$/.test(filename.split(import_node_path2.default.sep).join("/"));
+}
+function isLayoutFile(filename) {
+  return /(^|\/)layout\.[cm]?[jt]sx?$/.test(filename.split(import_node_path2.default.sep).join("/"));
+}
+function isRootLayoutFile(filename) {
+  const normalized = filename.split(import_node_path2.default.sep).join("/");
+  return /(^|\/)(src\/)?app\/layout\.[cm]?[jt]sx?$/.test(normalized);
+}
+function isDynamicRoute(filename) {
+  return /\[[^/]+\]/.test(filename);
+}
+function routeIsPrivate(filename, privateRoutes = ["/admin", "/api", "/auth", "/private"]) {
+  const normalized = filename.split(import_node_path2.default.sep).join("/");
+  return privateRoutes.some(
+    (route) => normalized.includes(`/app${route}/`) || normalized.includes(`/src/app${route}/`)
+  );
+}
+function hasMetadataBase(root = findProjectRoot()) {
+  const appDir = findAppDir(root);
+  if (!appDir) return false;
+  for (const ext of ["ts", "tsx", "js", "jsx", "mts", "mjs"]) {
+    const file = import_node_path2.default.join(appDir, `layout.${ext}`);
+    if (import_node_fs.default.existsSync(file) && import_node_fs.default.readFileSync(file, "utf8").includes("metadataBase")) return true;
+  }
+  return false;
+}
+function routeSegmentDir(filename) {
+  return import_node_path2.default.dirname(filename);
+}
+function hasOpenGraphImageRoute(filename) {
+  const dir = routeSegmentDir(filename);
+  return [
+    "opengraph-image.tsx",
+    "opengraph-image.ts",
+    "opengraph-image.png",
+    "opengraph-image.jpg",
+    "opengraph-image.jpeg"
+  ].some((name) => import_node_fs.default.existsSync(import_node_path2.default.join(dir, name)));
+}
+function routeFromFilename(filename) {
+  const normalized = filename.split(import_node_path2.default.sep).join("/");
+  const appIndex = normalized.lastIndexOf("/app/");
+  const relative = appIndex >= 0 ? normalized.slice(appIndex + 5) : normalized;
+  const route = relative.replace(/\/(page|layout)\.[cm]?[jt]sx?$/, "").replace(/\/?$/, "").replace(/\/\([^/]+\)/g, "").replace(/\/route$/, "");
+  return `/${route}`.replace(/\/+/g, "/") || "/";
+}
+
+// src/utils/rule.ts
+function createRule(name, description, create, type = "problem") {
+  return {
+    meta: {
+      type,
+      docs: {
+        description,
+        recommended: true,
+        url: `https://seo-lint-next.dev/rules/${name}`
+      },
+      schema: [
+        {
+          type: "object",
+          additionalProperties: true
+        }
+      ],
+      messages: {}
+    },
+    create
+  };
+}
+function report(context, node, message) {
+  context.report({ node, message });
+}
+
+// src/rules/no-accidental-noindex.ts
+var checkedRobots = false;
+var noAccidentalNoindex = createRule(
+  "no-accidental-noindex",
+  "prevent public pages and robots files from disabling indexing",
+  (context) => ({
+    "Program:exit"(program) {
+      const filename = context.getFilename();
+      const options = context.options[0] ?? {};
+      const privateRoutes = options.privateRoutes;
+      if (isPageFile(filename) && !routeIsPrivate(filename, privateRoutes)) {
+        for (const source of metadataSources(program)) {
+          const robots = getPathProperty(source, ["robots"]);
+          if (!robots) continue;
+          if (getStaticString(robots.value)?.toLowerCase().includes("noindex")) {
+            report(
+              context,
+              robots.node,
+              'Public page sets robots: "noindex"; this can remove the page from search indexes.'
+            );
+          }
+          const index = getObjectProperty(robots.value, "index");
+          if (index?.value.type === "Literal" && index.value.value === false) {
+            report(context, index.node, "Public page sets robots.index to false.");
+          }
+        }
+      }
+      walk(program, (node) => {
+        if (node.type !== "ConditionalExpression" && node.type !== "LogicalExpression") return;
+        const text = context.sourceCode.getText(node);
+        if (/NODE_ENV/.test(text) && /noindex/.test(text) && /production/.test(text)) {
+          report(
+            context,
+            node,
+            "Environment-gated noindex logic should be reviewed; production pages must not emit noindex."
+          );
+        }
+      });
+      if (checkedRobots) return;
+      checkedRobots = true;
+      const root = findProjectRoot(process.cwd());
+      const appDir = findAppDir(root);
+      const robotsTs = appDir ? ["robots.ts", "robots.js"].map((name) => import_node_path3.default.join(appDir, name)).find(import_node_fs2.default.existsSync) : void 0;
+      if (robotsTs) {
+        const text = import_node_fs2.default.readFileSync(robotsTs, "utf8");
+        if (/disallow\s*:\s*['"`]\/['"`]/i.test(text) && !/allow\s*:\s*['"`]\/['"`]/i.test(text)) {
+          report(context, program, `${robotsTs} appears to disallow "/" without an allow rule.`);
+        }
+      }
+      const publicRobots = import_node_path3.default.join(root, "public", "robots.txt");
+      if (import_node_fs2.default.existsSync(publicRobots)) {
+        const text = import_node_fs2.default.readFileSync(publicRobots, "utf8");
+        if (/^\s*Disallow:\s*\/\s*$/im.test(text) && !/^\s*Allow:\s*\/.+/im.test(text)) {
+          report(context, program, 'public/robots.txt disallows all crawling with "Disallow: /".');
+        }
+      }
+      const nextConfig = ["next.config.js", "next.config.mjs", "next.config.ts"].map((name) => import_node_path3.default.join(root, name)).find(import_node_fs2.default.existsSync);
+      if (nextConfig) {
+        const text = import_node_fs2.default.readFileSync(nextConfig, "utf8");
+        if (/X-Robots-Tag/i.test(text) && /noindex/i.test(text)) {
+          report(
+            context,
+            program,
+            "next.config sets X-Robots-Tag: noindex; verify this is not applied to public routes."
+          );
+        }
+      }
+    }
+  })
+);
+
+// src/rules/no-broken-heading-hierarchy.ts
+var noBrokenHeadingHierarchy = createRule(
+  "no-broken-heading-hierarchy",
+  "require one h1 and sequential heading levels",
+  (context) => {
+    const headings = [];
+    return {
+      JSXOpeningElement(node) {
+        if (!isPageFile(context.getFilename())) return;
+        const name = getNodeName(node.name);
+        if (!name || !/^h[1-6]$/.test(name)) return;
+        const ariaHidden = jsxAttributeString(node, "aria-hidden");
+        headings.push({ level: Number(name.slice(1)), node, empty: ariaHidden === "true" });
+      },
+      "Program:exit"(program) {
+        if (!isPageFile(context.getFilename())) return;
+        const h1s = headings.filter((heading) => heading.level === 1);
+        if (h1s.length === 0)
+          report(context, program, "Page has no <h1>; each indexable page should expose one primary heading.");
+        if (h1s.length > 1) {
+          for (const h1 of h1s.slice(1))
+            report(context, h1.node, "Page has more than one <h1>; keep one primary topic heading.");
+        }
+        for (let index = 1; index < headings.length; index += 1) {
+          if (headings[index].level > headings[index - 1].level + 1) {
+            report(
+              context,
+              headings[index].node,
+              `Heading level jumps from h${headings[index - 1].level} to h${headings[index].level}.`
+            );
+          }
+        }
+      }
+    };
+  },
+  "suggestion"
+);
+
+// src/rules/no-img-missing-alt.ts
+var meaningless = /* @__PURE__ */ new Set(["image", "img", "photo", "picture", "screenshot"]);
+var noImgMissingAlt = createRule(
+  "no-img-missing-alt",
+  "require useful alt text and stable Next/Image sizing",
+  (context) => {
+    let imageIndex = 0;
+    return {
+      JSXOpeningElement(node) {
+        const typed = node;
+        const name = getNodeName(node.name);
+        if (name !== "img" && name !== "Image") return;
+        imageIndex += 1;
+        if (name === "img")
+          report(context, typed, "Use next/image instead of raw <img> for optimized image delivery.");
+        const altAttribute = jsxAttribute(typed, "alt");
+        if (!altAttribute) {
+          report(context, typed, `${name} is missing an alt attribute.`);
+        } else {
+          const alt = jsxAttributeString(typed, "alt");
+          if (alt === void 0) return;
+          if (alt.length > 125)
+            report(context, altAttribute, "Alt text should stay under 125 characters.");
+          const normalized = alt.trim().toLowerCase();
+          if (normalized && (meaningless.has(normalized) || /\.(png|jpe?g|webp|gif|svg)$/i.test(normalized))) {
+            report(
+              context,
+              altAttribute,
+              'Alt text is too generic; describe the image content or use alt="" for decorative images.'
+            );
+          }
+        }
+        if (name === "Image") {
+          if (!jsxAttribute(typed, "width") || !jsxAttribute(typed, "height")) {
+            report(context, typed, "<Image> should include width and height props to prevent layout shift.");
+          }
+          if (imageIndex === 1 && !jsxAttribute(typed, "priority")) {
+            report(
+              context,
+              typed,
+              "The first <Image> in a page is likely above the fold; add priority when it is the LCP image."
+            );
+          }
+        }
+      }
+    };
+  },
+  "suggestion"
+);
+
+// src/rules/no-invalid-json-ld.ts
+var requiredFields = {
+  Article: ["headline", "author", "datePublished"],
+  BlogPosting: ["headline", "author", "datePublished"],
+  Product: ["name", "offers"],
+  FAQPage: ["mainEntity"],
+  BreadcrumbList: ["itemListElement"],
+  Organization: ["name", "url"],
+  WebSite: ["name", "url"],
+  Person: ["name"],
+  Event: ["name", "startDate", "location"]
+};
+var recognized = new Set(Object.keys(requiredFields));
+var noInvalidJsonLd = createRule(
+  "no-invalid-json-ld",
+  "validate JSON-LD syntax and required schema fields",
+  (context) => {
+    let scriptCount = 0;
+    return {
+      JSXElement(node) {
+        const opening = node.openingElement;
+        if (getNodeName(opening?.name) !== "script") return;
+        if (jsxAttributeString(opening, "type") !== "application/ld+json") return;
+        scriptCount += 1;
+        const html = (opening.attributes ?? []).find(
+          (attribute) => getNodeName(attribute.name) === "dangerouslySetInnerHTML"
+        );
+        if (html) {
+          const text2 = context.sourceCode.getText(html);
+          if (!/JSON\.stringify/.test(text2) && !/__html\s*:\s*['"`{]/.test(text2)) {
+            report(
+              context,
+              html,
+              "JSON-LD dangerouslySetInnerHTML should pass JSON.stringify(data) or a static JSON string."
+            );
+          }
+          return;
+        }
+        const text = extractScriptText(node.children ?? []);
+        if (!text) return;
+        try {
+          validateJsonLd(JSON.parse(text), (message) => report(context, node, message));
+        } catch {
+          report(context, node, "JSON-LD script contains invalid JSON.");
+        }
+      },
+      "Program:exit"(program) {
+        if (!isPageFile(context.getFilename())) return;
+        const route = routeFromFilename(context.getFilename());
+        if (/\/(blog|posts|product|products|articles)(\/|$)/.test(route) && scriptCount === 0) {
+          report(context, program, "Content page is missing an application/ld+json structured data block.");
+        }
+        let websiteSchema = false;
+        walk(program, (child) => {
+          if (child.type === "Literal" && child.value === "WebSite") websiteSchema = true;
+        });
+        if (/\/layout\.[cm]?[jt]sx?$/.test(context.getFilename()) && !websiteSchema) {
+          report(
+            context,
+            program,
+            "Root layout should include WebSite JSON-LD with SearchAction for sitelinks search eligibility."
+          );
+        }
+      }
+    };
+  }
+);
+function extractScriptText(children) {
+  return children.map((child) => {
+    if (typeof child.value === "string") return child.value;
+    if (child.type === "JSXExpressionContainer") return getStaticString(child.expression) ?? "";
+    return "";
+  }).join("").trim();
+}
+function validateJsonLd(value, onError) {
+  const items = Array.isArray(value) ? value : [value];
+  const byType = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (!item || typeof item !== "object") continue;
+    const record = item;
+    if (record["@context"] !== "https://schema.org")
+      onError('JSON-LD @context must be exactly "https://schema.org".');
+    const type = String(record["@type"] ?? "");
+    if (!recognized.has(type))
+      onError(`JSON-LD @type "${type || "(missing)"}" is not in the built-in recognized type list.`);
+    const missing = (requiredFields[type] ?? []).filter((field) => record[field] == null);
+    if (missing.length > 0) onError(`JSON-LD ${type} is missing required field(s): ${missing.join(", ")}.`);
+    const serialized = JSON.stringify(record);
+    const previous = byType.get(type);
+    if (previous && previous !== serialized)
+      onError(`Multiple JSON-LD ${type} blocks contain conflicting data.`);
+    byType.set(type, serialized);
+  }
+}
+
+// src/rules/no-missing-canonical.ts
+var noMissingCanonical = createRule(
+  "no-missing-canonical",
+  "require canonical URLs for App Router pages",
+  (context) => ({
+    "Program:exit"(program) {
+      const filename = context.getFilename();
+      if (!isPageFile(filename)) return;
+      const sources = metadataSources(program);
+      const canonical = sources.map((source) => getPathProperty(source, ["alternates", "canonical"])).find(Boolean);
+      if (!canonical) {
+        report(
+          context,
+          program,
+          "Page is missing alternates.canonical; duplicate URL variants can split ranking signals."
+        );
+        return;
+      }
+      const value = getStaticString(canonical.value);
+      if (value && !/^https?:\/\//.test(value) && !value.startsWith("/") && !hasMetadataBase()) {
+        report(
+          context,
+          canonical.node,
+          "Relative alternates.canonical requires metadataBase in the root app layout."
+        );
+      }
+      if (isDynamicRoute(filename) && value && !hasDynamicInterpolation(canonical.value)) {
+        report(
+          context,
+          canonical.node,
+          "Dynamic routes need a param-specific canonical, not a hardcoded URL string."
+        );
+      }
+    }
+  })
+);
+
+// src/rules/no-missing-description.ts
+var seenDescriptions = /* @__PURE__ */ new Map();
+var noMissingDescription = createRule(
+  "no-missing-description",
+  "require useful Next.js metadata descriptions",
+  (context) => ({
+    "Program:exit"(program) {
+      const filename = context.getFilename();
+      if (!isPageFile(filename) && !isLayoutFile(filename)) return;
+      const option = context.options[0] ?? {};
+      const min = option.descriptionLength?.min ?? 120;
+      const max = option.descriptionLength?.max ?? 160;
+      const sources = metadataSources(program);
+      const description = sources.map((source) => getPathProperty(source, ["description"])).find(Boolean);
+      if (!description) {
+        report(
+          context,
+          program,
+          "Page is missing metadata.description or a generateMetadata() description return value."
+        );
+        return;
+      }
+      const value = getStaticString(description.value);
+      if (typeof value !== "string" || value.trim().length === 0) {
+        report(context, description.node, "metadata.description must not be empty or whitespace.");
+        return;
+      }
+      if (value.length < min || value.length > max) {
+        report(
+          context,
+          description.node,
+          `metadata.description should be ${min}-${max} characters; found ${value.length}.`
+        );
+      }
+      const title = sources.map((source) => getPathProperty(source, ["title"])).find(Boolean);
+      const titleValue = title ? getStaticString(title.value) : void 0;
+      if (titleValue && value.startsWith(titleValue)) {
+        report(
+          context,
+          description.node,
+          "metadata.description should not start with the exact page title."
+        );
+      }
+      const route = routeFromFilename(filename);
+      const previous = seenDescriptions.get(value);
+      if (previous && previous !== route) {
+        report(
+          context,
+          description.node,
+          `Duplicate metadata.description also appears in ${previous}.`
+        );
+      } else {
+        seenDescriptions.set(value, route);
+      }
+    }
+  }),
+  "suggestion"
+);
+
+// src/rules/no-missing-metadata-base.ts
+var noMissingMetadataBase = createRule(
+  "no-missing-metadata-base",
+  "require production metadataBase in the root app layout",
+  (context) => ({
+    "Program:exit"(program) {
+      const filename = context.getFilename();
+      if (!isRootLayoutFile(filename)) return;
+      const metadata = metadataSources(program)[0];
+      const metadataBase = metadata ? getPathProperty(metadata, ["metadataBase"]) : void 0;
+      if (!metadataBase) {
+        report(
+          context,
+          program,
+          "Root app layout is missing metadata.metadataBase; relative canonicals and OG images will not resolve safely."
+        );
+        return;
+      }
+      const value = metadataBase.value;
+      if (value.type !== "NewExpression" || value.callee?.type !== "Identifier" || value.callee.name !== "URL") {
+        report(
+          context,
+          metadataBase.node,
+          'metadataBase should be created with new URL("https://example.com").'
+        );
+        return;
+      }
+      const firstArg = Array.isArray(value.arguments) ? value.arguments[0] : void 0;
+      const literal = getStaticString(firstArg);
+      if (literal) {
+        if (!literal.startsWith("https://")) {
+          report(
+            context,
+            metadataBase.node,
+            "metadataBase must use an absolute https:// production URL."
+          );
+        }
+        if (/localhost|127\.0\.0\.1|0\.0\.0\.0/.test(literal)) {
+          report(
+            context,
+            metadataBase.node,
+            "metadataBase must not point at localhost in committed source."
+          );
+        }
+      }
+    }
+  })
+);
+
+// src/rules/no-missing-og-tags.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_image_size = require("image-size");
+var noMissingOgTags = createRule(
+  "no-missing-og-tags",
+  "require Open Graph and Twitter metadata",
+  (context) => ({
+    "Program:exit"(program) {
+      const filename = context.getFilename();
+      if (!isPageFile(filename)) return;
+      const source = metadataSources(program)[0];
+      if (!source) return;
+      const openGraph = getPathProperty(source, ["openGraph"]);
+      if (!openGraph) {
+        if (!hasOpenGraphImageRoute(filename)) report(context, program, "Page is missing openGraph metadata.");
+        return;
+      }
+      for (const key of ["title", "description", "type"]) {
+        if (!getObjectProperty(openGraph.value, key)) {
+          report(context, openGraph.node, `openGraph.${key} is missing.`);
+        }
+      }
+      const images = getObjectProperty(openGraph.value, "images");
+      if (!images && !hasOpenGraphImageRoute(filename)) {
+        report(
+          context,
+          openGraph.node,
+          "openGraph.images is missing and no opengraph-image file exists in this route segment."
+        );
+      } else if (images?.value.type === "ArrayExpression" && (images.value.elements ?? []).length === 0) {
+        report(context, images.node, "openGraph.images must include at least one image.");
+      }
+      if (images?.value.type === "ArrayExpression") {
+        for (const image of images.value.elements ?? []) {
+          if (!image) continue;
+          const urlNode = getObjectProperty(image, "url")?.value ?? image;
+          const url = getStaticString(urlNode);
+          if (url?.startsWith("/") && !hasMetadataBase()) {
+            report(
+              context,
+              images.node,
+              "Relative openGraph image URLs require metadataBase in the root app layout."
+            );
+          }
+          const width = Number(getObjectProperty(image, "width")?.value?.value ?? 0);
+          const height = Number(getObjectProperty(image, "height")?.value?.value ?? 0);
+          if (width && width < 800 || height && height < 418) {
+            report(
+              context,
+              images.node,
+              "Open Graph image dimensions should be at least 800x418, ideally 1200x630."
+            );
+          }
+          if (url?.startsWith("/")) {
+            const publicFile = import_node_path4.default.join(process.cwd(), "public", url);
+            if (import_node_fs3.default.existsSync(publicFile)) {
+              const size = (0, import_image_size.imageSize)(import_node_fs3.default.readFileSync(publicFile));
+              if ((size.width ?? 0) < 800 || (size.height ?? 0) < 418) {
+                report(context, images.node, `Open Graph image file ${url} is smaller than 800x418.`);
+              }
+            }
+          }
+        }
+      }
+      const twitter = getObjectProperty(source, "twitter");
+      if (!twitter) {
+        report(
+          context,
+          source,
+          "twitter metadata is missing; set twitter.card and twitter.images for share previews."
+        );
+        return;
+      }
+      const card = getObjectProperty(twitter.value, "card");
+      if (!card)
+        report(
+          context,
+          twitter.node,
+          'twitter.card is missing; use "summary_large_image" for OG-style previews.'
+        );
+      if (getStaticString(card?.value) === "summary_large_image" && !getObjectProperty(twitter.value, "images")) {
+        report(
+          context,
+          twitter.node,
+          'twitter.images is required when twitter.card is "summary_large_image".'
+        );
+      }
+    }
+  }),
+  "suggestion"
+);
+
+// src/rules/no-missing-sitemap.ts
+var import_node_fs4 = __toESM(require("fs"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
+var checked = false;
+var noMissingSitemap = createRule(
+  "no-missing-sitemap",
+  "require a Next.js sitemap and robots sitemap reference",
+  (context) => ({
+    "Program:exit"(program) {
+      if (checked) return;
+      checked = true;
+      const root = findProjectRoot(process.cwd());
+      const appDir = findAppDir(root);
+      const sitemap = appDir ? ["sitemap.ts", "sitemap.js", "sitemap.mjs"].map((name) => import_node_path5.default.join(appDir, name)).find(import_node_fs4.default.existsSync) : void 0;
+      const nextSitemap = import_node_path5.default.join(root, "next-sitemap.config.js");
+      if (!sitemap && !import_node_fs4.default.existsSync(nextSitemap)) {
+        report(
+          context,
+          program,
+          "Missing app/sitemap.ts or next-sitemap.config.js; search engines may discover pages slowly."
+        );
+        return;
+      }
+      if (sitemap) {
+        const text = import_node_fs4.default.readFileSync(sitemap, "utf8");
+        if (!/export\s+default\s+(async\s+)?function|export\s+default\s+\w+/.test(text)) {
+          report(context, program, `${sitemap} should export a default sitemap function.`);
+        }
+        if (/url\s*:\s*['"`]\//.test(text)) {
+          report(context, program, "Sitemap entries must use absolute URLs, not relative paths.");
+        }
+        if (/\[[^/]+\]/.test(text) && !/lastModified/.test(text)) {
+          report(context, program, "Dynamic sitemap entries should include lastModified.");
+        }
+      }
+      const robots = appDir ? ["robots.ts", "robots.js"].map((name) => import_node_path5.default.join(appDir, name)).find(import_node_fs4.default.existsSync) : void 0;
+      if (robots && !/sitemap\s*:/.test(import_node_fs4.default.readFileSync(robots, "utf8"))) {
+        report(context, program, "app/robots.ts should include a sitemap field pointing to the sitemap URL.");
+      }
+    }
+  }),
+  "suggestion"
+);
+
+// src/rules/no-missing-title.ts
+var seenTitles = /* @__PURE__ */ new Map();
+var noMissingTitle = createRule(
+  "no-missing-title",
+  "require useful Next.js metadata titles",
+  (context) => ({
+    "Program:exit"(program) {
+      const filename = context.getFilename();
+      if (!isPageFile(filename) && !isLayoutFile(filename)) return;
+      const sources = metadataSources(program);
+      const title = sources.map((source) => getPathProperty(source, ["title"])).find(Boolean);
+      if (!title) {
+        report(context, program, "Page is missing metadata.title or a generateMetadata() title return value.");
+        return;
+      }
+      if (title.value.type === "Literal" && String(title.value.value ?? "").trim().length === 0) {
+        report(context, title.node, "metadata.title must not be empty or whitespace.");
+      }
+      const titleString = getStaticString(title.value);
+      if (titleString?.trim()) {
+        const route = routeFromFilename(filename);
+        const previous = seenTitles.get(titleString);
+        if (previous && previous !== filename) {
+          report(
+            context,
+            title.node,
+            `Duplicate metadata.title "${titleString}" also appears in ${previous}.`
+          );
+        } else {
+          seenTitles.set(titleString, route);
+        }
+      }
+      if (isLayoutFile(filename) && !getPathProperty(title.value, ["template"])) {
+        report(
+          context,
+          title.node,
+          'Root/layout metadata.title should define a title.template such as "%s | Brand".'
+        );
+      }
+      if (title.value.type !== "ObjectExpression" && !getStaticString(title.value) && !hasNullishFallback(title.value)) {
+        report(
+          context,
+          title.node,
+          'Dynamic metadata.title should include a non-empty fallback with ?? "Fallback title".'
+        );
+      }
+    }
+  })
+);
+
+// src/eslint.ts
+var rules = {
+  "no-missing-title": noMissingTitle,
+  "no-missing-metadata-base": noMissingMetadataBase,
+  "no-missing-description": noMissingDescription,
+  "no-missing-canonical": noMissingCanonical,
+  "no-missing-og-tags": noMissingOgTags,
+  "no-broken-heading-hierarchy": noBrokenHeadingHierarchy,
+  "no-img-missing-alt": noImgMissingAlt,
+  "no-accidental-noindex": noAccidentalNoindex,
+  "no-missing-sitemap": noMissingSitemap,
+  "no-invalid-json-ld": noInvalidJsonLd
+};
+var recommendedRules = {
+  "seo-lint-next/no-missing-title": "error",
+  "seo-lint-next/no-missing-metadata-base": "error",
+  "seo-lint-next/no-missing-description": "warn",
+  "seo-lint-next/no-missing-canonical": "error",
+  "seo-lint-next/no-missing-og-tags": "warn",
+  "seo-lint-next/no-broken-heading-hierarchy": "warn",
+  "seo-lint-next/no-img-missing-alt": "warn",
+  "seo-lint-next/no-accidental-noindex": "error",
+  "seo-lint-next/no-missing-sitemap": "warn",
+  "seo-lint-next/no-invalid-json-ld": "error"
+};
+var plugin = {
+  meta: {
+    name: "seo-lint-next",
+    version: "0.1.0"
+  },
+  rules,
+  configs: {
+    recommended: [
+      {
+        plugins: {
+          "seo-lint-next": null
+        },
+        rules: recommendedRules
+      }
+    ],
+    legacyRecommended: {
+      plugins: ["seo-lint-next"],
+      rules: recommendedRules
+    }
+  }
+};
+plugin.configs.recommended[0].plugins["seo-lint-next"] = plugin;
+var eslint_default = plugin;
+
+// src/cli.ts
+var defaultSeverities = {
+  "no-missing-title": 2,
+  "no-missing-metadata-base": 2,
+  "no-missing-description": 1,
+  "no-missing-canonical": 2,
+  "no-missing-og-tags": 1,
+  "no-broken-heading-hierarchy": 1,
+  "no-img-missing-alt": 1,
+  "no-accidental-noindex": 2,
+  "no-missing-sitemap": 1,
+  "no-invalid-json-ld": 2
+};
+async function main() {
+  const options = parseArgs(import_node_process.default.argv.slice(2));
+  const cwd = import_node_process.default.cwd();
+  const appDir = import_node_path6.default.resolve(cwd, options.dir);
+  if (!import_node_fs5.default.existsSync(appDir)) {
+    console.error(`seo-lint-next: app directory not found: ${options.dir}`);
+    import_node_process.default.exitCode = 2;
+    return;
+  }
+  const files = await (0, import_fast_glob.default)(["**/*.{ts,tsx,js,jsx,mts,mjs}"], {
+    cwd: appDir,
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/.next/**"]
+  });
+  const linter = createLinter();
+  const rules2 = Object.fromEntries(
+    Object.keys(defaultSeverities).map((ruleName) => [
+      `seo-lint-next/${ruleName}`,
+      options.strict && defaultSeverities[ruleName] === 1 ? 2 : defaultSeverities[ruleName]
+    ])
+  );
+  const results = files.map((filePath) => {
+    const text = import_node_fs5.default.readFileSync(filePath, "utf8");
+    const messages = linter.verify(
+      text,
+      {
+        parser: "@typescript-eslint/parser",
+        parserOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module",
+          ecmaFeatures: { jsx: true }
+        },
+        rules: rules2
+      },
+      { filename: filePath }
+    );
+    return { filePath, messages };
+  });
+  if (options.format === "json") {
+    console.log(JSON.stringify(results, null, 2));
+  } else {
+    printStylish(results);
+  }
+  const hasErrors = results.some((result) => result.messages.some((message) => message.severity === 2));
+  import_node_process.default.exitCode = hasErrors ? 1 : 0;
+}
+function createLinter() {
+  let linter;
+  try {
+    linter = new import_eslint.Linter({ configType: "eslintrc" });
+  } catch {
+    linter = new import_eslint.Linter();
+  }
+  linter.defineParser("@typescript-eslint/parser", import_parser.default);
+  for (const [ruleName, rule] of Object.entries(eslint_default.rules)) {
+    linter.defineRule(`seo-lint-next/${ruleName}`, rule);
+  }
+  return linter;
+}
+function parseArgs(args) {
+  const options = { dir: "app", format: "stylish", strict: false };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--dir") options.dir = args[++index] ?? options.dir;
+    else if (arg === "--format") {
+      const format = args[++index];
+      if (format === "json" || format === "stylish") options.format = format;
+      else throw new Error(`Unsupported format: ${format}`);
+    } else if (arg === "--strict") options.strict = true;
+    else if (arg === "--help" || arg === "-h") {
+      console.log(`seo-lint-next
+
+Usage:
+  seo-lint-next [--dir app] [--format stylish|json] [--strict]
+
+Options:
+  --dir       App Router directory to lint. Defaults to app.
+  --format    Output format. Defaults to stylish.
+  --strict    Treat warnings as errors.
+`);
+      import_node_process.default.exit(0);
+    }
+  }
+  return options;
+}
+function printStylish(results) {
+  let count = 0;
+  for (const result of results) {
+    if (result.messages.length === 0) continue;
+    console.log(result.filePath);
+    for (const message of result.messages) {
+      count += 1;
+      const level = message.severity === 2 ? "error" : "warning";
+      const line = String(message.line ?? 1).padStart(4);
+      const column = String(message.column ?? 1).padEnd(3);
+      console.log(`  ${line}:${column}  ${level.padEnd(7)}  ${message.message}  ${message.ruleId ?? ""}`);
+    }
+    console.log("");
+  }
+  if (count > 0) console.log(`${count} SEO issue${count === 1 ? "" : "s"} found.`);
+}
+main().catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  import_node_process.default.exitCode = 2;
+});
+//# sourceMappingURL=cli.cjs.map