@ijonis/geo-lint 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2691 @@
+"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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createAdapter: () => createAdapter,
+  defineConfig: () => defineConfig,
+  lint: () => lint,
+  lintQuiet: () => lintQuiet,
+  loadContentItems: () => loadContentItems
+});
+module.exports = __toCommonJS(src_exports);
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/index.ts
+var import_node_path4 = require("path");
+
+// src/config/loader.ts
+var import_node_fs = require("fs");
+var import_node_fs2 = require("fs");
+var import_node_path = require("path");
+
+// src/config/defaults.ts
+var DEFAULT_CONFIG = {
+  contentPaths: [
+    { dir: "content/blog", type: "blog", urlPrefix: "/blog/" },
+    { dir: "content/pages", type: "page", urlPrefix: "/" },
+    { dir: "content/projects", type: "project", urlPrefix: "/projects/" }
+  ],
+  staticRoutes: [],
+  imageDirectories: ["public/images"],
+  categories: [],
+  excludeSlugs: [],
+  excludeCategories: ["legal"],
+  geo: {
+    brandName: "",
+    brandCity: "",
+    keywordsPath: ""
+  },
+  rules: {},
+  thresholds: {
+    title: { minLength: 30, maxLength: 60, warnLength: 55 },
+    description: { minLength: 70, maxLength: 160, warnLength: 150 },
+    slug: { maxLength: 75 },
+    content: { minWordCount: 300, minReadabilityScore: 30 }
+  }
+};
+
+// src/config/loader.ts
+var CONFIG_FILENAMES = [
+  "geo-lint.config.ts",
+  "geo-lint.config.mts",
+  "geo-lint.config.mjs",
+  "geo-lint.config.js"
+];
+function defineConfig(config) {
+  return config;
+}
+async function tryLoadConfigFile(projectRoot) {
+  for (const filename of CONFIG_FILENAMES) {
+    const configPath = (0, import_node_path.join)(projectRoot, filename);
+    if (!(0, import_node_fs.existsSync)(configPath)) continue;
+    try {
+      const { createJiti } = await import("jiti");
+      const jiti = createJiti(importMetaUrl);
+      const mod = await jiti.import(configPath);
+      const config = mod.default ?? mod;
+      if (config && typeof config === "object" && "siteUrl" in config) {
+        return config;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function tryLoadPackageJsonConfig(projectRoot) {
+  try {
+    const pkgPath = (0, import_node_path.join)(projectRoot, "package.json");
+    if (!(0, import_node_fs.existsSync)(pkgPath)) return null;
+    const pkg = JSON.parse((0, import_node_fs2.readFileSync)(pkgPath, "utf-8"));
+    const config = pkg.geoLint;
+    if (config && typeof config === "object" && "siteUrl" in config) {
+      return config;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function mergeWithDefaults(user) {
+  return {
+    siteUrl: user.siteUrl,
+    contentPaths: user.contentPaths ?? DEFAULT_CONFIG.contentPaths,
+    staticRoutes: user.staticRoutes ?? DEFAULT_CONFIG.staticRoutes,
+    imageDirectories: user.imageDirectories ?? DEFAULT_CONFIG.imageDirectories,
+    categories: user.categories ?? DEFAULT_CONFIG.categories,
+    excludeSlugs: user.excludeSlugs ?? DEFAULT_CONFIG.excludeSlugs,
+    excludeCategories: user.excludeCategories ?? DEFAULT_CONFIG.excludeCategories,
+    geo: {
+      brandName: user.geo?.brandName ?? DEFAULT_CONFIG.geo.brandName,
+      brandCity: user.geo?.brandCity ?? DEFAULT_CONFIG.geo.brandCity,
+      keywordsPath: user.geo?.keywordsPath ?? DEFAULT_CONFIG.geo.keywordsPath
+    },
+    rules: { ...DEFAULT_CONFIG.rules, ...user.rules ?? {} },
+    thresholds: {
+      title: { ...DEFAULT_CONFIG.thresholds.title, ...user.thresholds?.title ?? {} },
+      description: { ...DEFAULT_CONFIG.thresholds.description, ...user.thresholds?.description ?? {} },
+      slug: { ...DEFAULT_CONFIG.thresholds.slug, ...user.thresholds?.slug ?? {} },
+      content: { ...DEFAULT_CONFIG.thresholds.content, ...user.thresholds?.content ?? {} }
+    }
+  };
+}
+async function loadConfig(projectRoot) {
+  const root = (0, import_node_path.resolve)(projectRoot ?? process.cwd());
+  const userConfig = await tryLoadConfigFile(root) ?? tryLoadPackageJsonConfig(root);
+  if (!userConfig) {
+    throw new Error(
+      'geo-lint: No configuration found.\nCreate a geo-lint.config.ts in your project root with at least:\n\n  import { defineConfig } from "@ijonis/geo-lint";\n  export default defineConfig({ siteUrl: "https://example.com" });\n\nSee https://github.com/ijonis/geo-lint#configuration'
+    );
+  }
+  return mergeWithDefaults(userConfig);
+}
+
+// src/adapters/mdx.ts
+var import_node_fs3 = require("fs");
+var import_node_path2 = require("path");
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+function derivePermalink(slug, locale, pathConfig) {
+  const prefix = pathConfig.urlPrefix ?? "/";
+  if (pathConfig.type === "page") {
+    return `/${slug}`.replace(/\/\/+/g, "/");
+  }
+  const defaultLocale = pathConfig.defaultLocale ?? "de";
+  if (locale && locale !== defaultLocale) {
+    return `/${locale}${prefix}${slug}`.replace(/\/\/+/g, "/");
+  }
+  return `${prefix}${slug}`.replace(/\/\/+/g, "/");
+}
+function findContentFiles(dir) {
+  const files = [];
+  if (!(0, import_node_fs3.existsSync)(dir)) return files;
+  for (const entry of (0, import_node_fs3.readdirSync)(dir)) {
+    const fullPath = (0, import_node_path2.join)(dir, entry);
+    try {
+      const stat = (0, import_node_fs3.statSync)(fullPath);
+      if (stat.isDirectory()) {
+        files.push(...findContentFiles(fullPath));
+      } else if (entry.endsWith(".mdx") || entry.endsWith(".md")) {
+        files.push(fullPath);
+      }
+    } catch {
+    }
+  }
+  return files;
+}
+function parseContentFile(filePath, pathConfig) {
+  try {
+    const { data: fm, content: body, orig } = import_gray_matter.default.read(filePath);
+    const slug = fm.slug;
+    if (!slug) return null;
+    if (fm.draft === true) return null;
+    const locale = fm.locale;
+    const permalink = fm.permalink ?? derivePermalink(slug, locale, pathConfig);
+    return {
+      title: fm.title ?? "",
+      slug,
+      description: fm.description ?? "",
+      permalink,
+      image: fm.image ?? fm.thumbnail,
+      imageAlt: fm.imageAlt,
+      categories: fm.categories,
+      date: fm.date ? String(fm.date) : void 0,
+      category: fm.category,
+      locale,
+      translationKey: fm.translationKey,
+      updatedAt: fm.updatedAt ? String(fm.updatedAt) : void 0,
+      noindex: fm.noindex,
+      draft: fm.draft,
+      contentType: pathConfig.type,
+      filePath,
+      rawContent: orig?.toString() ?? "",
+      body
+    };
+  } catch {
+    return null;
+  }
+}
+function loadContentItems(contentPaths, projectRoot) {
+  const items = [];
+  for (const pathConfig of contentPaths) {
+    const fullDir = (0, import_node_path2.join)(projectRoot, pathConfig.dir);
+    const files = findContentFiles(fullDir);
+    for (const filePath of files) {
+      const item = parseContentFile(filePath, pathConfig);
+      if (item) items.push(item);
+    }
+  }
+  return items;
+}
+
+// src/utils/link-extractor.ts
+function createLinkExtractor(siteUrl) {
+  const { hostname } = new URL(siteUrl);
+  const escapedDomain = hostname.replace(/\./g, "\\.");
+  const internalPatterns = [
+    new RegExp(`^https?:\\/\\/(www\\.)?${escapedDomain}(\\/|$)`, "i"),
+    new RegExp(`^\\/\\/${escapedDomain}(\\/|$)`, "i"),
+    /^\/(?!\/)/
+    // Relative paths starting with single /
+  ];
+  function isInternalUrl(url) {
+    return internalPatterns.some((pattern) => pattern.test(url));
+  }
+  function normalizeInternalUrl(url) {
+    let normalized = url;
+    normalized = normalized.replace(new RegExp(`^https?:\\/\\/(www\\.)?${escapedDomain}`, "i"), "");
+    normalized = normalized.replace(new RegExp(`^\\/\\/${escapedDomain}`, "i"), "");
+    if (!normalized.startsWith("/")) {
+      normalized = "/" + normalized;
+    }
+    normalized = normalized.split("?")[0].split("#")[0];
+    if (normalized.length > 1 && normalized.endsWith("/")) {
+      normalized = normalized.slice(0, -1);
+    }
+    return normalized;
+  }
+  function isAbsoluteInternalLink(url) {
+    return new RegExp(`^https?:\\/\\/(www\\.)?${escapedDomain}`, "i").test(url);
+  }
+  function isInCodeBlock3(lines, lineIndex) {
+    let inCodeBlock = false;
+    for (let i = 0; i < lineIndex; i++) {
+      const line = lines[i].trim();
+      if (line.startsWith("```") || line.startsWith("~~~")) {
+        inCodeBlock = !inCodeBlock;
+      }
+    }
+    return inCodeBlock;
+  }
+  function extractLinks(mdxBody) {
+    const links = [];
+    const lines = mdxBody.split("\n");
+    const markdownLinkRegex = /(?<!!)\[([^\]]*)\]\(([^)]+)\)/g;
+    const hrefRegex = /href=["']([^"']+)["']/g;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (isInCodeBlock3(lines, i)) continue;
+      let match;
+      while ((match = markdownLinkRegex.exec(line)) !== null) {
+        const [, text, url] = match;
+        if (url.startsWith("mailto:") || url.startsWith("tel:") || url === "#") continue;
+        const internal = isInternalUrl(url);
+        links.push({
+          text: text.trim(),
+          url: internal ? normalizeInternalUrl(url) : url,
+          originalUrl: url,
+          line: i + 1,
+          isInternal: internal
+        });
+      }
+      markdownLinkRegex.lastIndex = 0;
+      while ((match = hrefRegex.exec(line)) !== null) {
+        const [, url] = match;
+        if (url.startsWith("mailto:") || url.startsWith("tel:") || url === "#") continue;
+        const normalized = isInternalUrl(url) ? normalizeInternalUrl(url) : url;
+        const alreadyCaptured = links.some(
+          (l) => l.line === i + 1 && (l.url === normalized || l.originalUrl === url)
+        );
+        if (!alreadyCaptured) {
+          const internal = isInternalUrl(url);
+          links.push({
+            text: "",
+            url: internal ? normalizeInternalUrl(url) : url,
+            originalUrl: url,
+            line: i + 1,
+            isInternal: internal
+          });
+        }
+      }
+      hrefRegex.lastIndex = 0;
+    }
+    return links;
+  }
+  function getInternalLinks(links) {
+    return links.filter((l) => l.isInternal);
+  }
+  return { isInternalUrl, normalizeInternalUrl, isAbsoluteInternalLink, extractLinks, getInternalLinks };
+}
+
+// src/utils/slug-resolver.ts
+var import_node_fs4 = require("fs");
+var import_node_path3 = require("path");
+function extractSlugFromFile(filePath) {
+  try {
+    const content = (0, import_node_fs4.readFileSync)(filePath, "utf-8");
+    if (!content.startsWith("---")) return null;
+    const endIndex = content.indexOf("---", 3);
+    if (endIndex === -1) return null;
+    const frontmatter = content.slice(3, endIndex);
+    const slugMatch = frontmatter.match(/^slug:\s*["']?([^"'\n]+)["']?\s*$/m);
+    if (!slugMatch) return null;
+    const localeMatch = frontmatter.match(/^locale:\s*["']?([^"'\n]+)["']?\s*$/m);
+    const draftMatch = frontmatter.match(/^draft:\s*true\s*$/m);
+    if (draftMatch) return null;
+    return {
+      slug: slugMatch[1].trim(),
+      locale: localeMatch ? localeMatch[1].trim() : "de"
+    };
+  } catch {
+    return null;
+  }
+}
+function findFilesInDir(dir, ext) {
+  const results = [];
+  try {
+    for (const entry of (0, import_node_fs4.readdirSync)(dir)) {
+      const fullPath = (0, import_node_path3.join)(dir, entry);
+      const stat = (0, import_node_fs4.statSync)(fullPath);
+      if (stat.isDirectory()) {
+        results.push(...findFilesInDir(fullPath, ext));
+      } else if (entry.endsWith(ext)) {
+        results.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return results;
+}
+function scanRawContentPermalinks(knownSlugs, contentPaths) {
+  const projectRoot = process.cwd();
+  const additionalPermalinks = [];
+  for (const pathConfig of contentPaths) {
+    const contentDir = (0, import_node_path3.join)(projectRoot, pathConfig.dir);
+    if (!(0, import_node_fs4.existsSync)(contentDir)) continue;
+    const urlPrefix = pathConfig.urlPrefix ?? "/";
+    for (const file of findFilesInDir(contentDir, ".mdx")) {
+      const meta = extractSlugFromFile(file);
+      if (!meta) continue;
+      let permalink;
+      const defaultLocale = pathConfig.defaultLocale ?? "de";
+      if (meta.locale !== defaultLocale && meta.locale !== "de") {
+        permalink = `/${meta.locale}${urlPrefix}${meta.slug}`.replace(/\/+/g, "/");
+      } else {
+        permalink = `${urlPrefix}${meta.slug}`.replace(/\/+/g, "/");
+      }
+      if (!permalink.startsWith("/")) {
+        permalink = "/" + permalink;
+      }
+      if (permalink.length > 1 && permalink.endsWith("/")) {
+        permalink = permalink.slice(0, -1);
+      }
+      if (!knownSlugs.has(permalink)) {
+        additionalPermalinks.push(permalink);
+      }
+    }
+  }
+  return additionalPermalinks;
+}
+function buildSlugRegistry(allContent, staticRoutes, contentPaths) {
+  const slugs = /* @__PURE__ */ new Set();
+  for (const route of staticRoutes) {
+    slugs.add(route);
+  }
+  for (const item of allContent) {
+    slugs.add(item.permalink);
+    if (item.permalink.endsWith("/") && item.permalink.length > 1) {
+      slugs.add(item.permalink.slice(0, -1));
+    }
+  }
+  const additional = scanRawContentPermalinks(slugs, contentPaths);
+  for (const permalink of additional) {
+    slugs.add(permalink);
+  }
+  return slugs;
+}
+function isValidInternalLink(url, validSlugs) {
+  if (validSlugs.has(url)) {
+    return true;
+  }
+  if (validSlugs.has(url + "/")) {
+    return true;
+  }
+  if (url.endsWith("/") && validSlugs.has(url.slice(0, -1))) {
+    return true;
+  }
+  return false;
+}
+function scanDirectory(dir) {
+  const files = [];
+  try {
+    const entries = (0, import_node_fs4.readdirSync)(dir);
+    for (const entry of entries) {
+      const fullPath = (0, import_node_path3.join)(dir, entry);
+      const stat = (0, import_node_fs4.statSync)(fullPath);
+      if (stat.isDirectory()) {
+        files.push(...scanDirectory(fullPath));
+      } else {
+        files.push(fullPath);
+      }
+    }
+  } catch {
+  }
+  return files;
+}
+function buildImageRegistry(imageDirectories) {
+  const images = /* @__PURE__ */ new Set();
+  const projectRoot = process.cwd();
+  for (const imageDir of imageDirectories) {
+    const fullDir = (0, import_node_path3.join)(projectRoot, imageDir);
+    if (!(0, import_node_fs4.existsSync)(fullDir)) {
+      continue;
+    }
+    const files = scanDirectory(fullDir);
+    for (const file of files) {
+      const relativePath = file.replace((0, import_node_path3.join)(projectRoot, "public"), "");
+      const normalizedPath = relativePath.replace(/\\/g, "/");
+      images.add(normalizedPath.startsWith("/") ? normalizedPath : "/" + normalizedPath);
+    }
+  }
+  return images;
+}
+function isValidImagePath(imagePath, validImages) {
+  let normalized = imagePath;
+  if (!normalized.startsWith("/")) {
+    normalized = "/" + normalized;
+  }
+  if (validImages.has(normalized)) {
+    return true;
+  }
+  try {
+    const decoded = decodeURIComponent(normalized);
+    if (validImages.has(decoded)) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/utils/display-path.ts
+function getDisplayPath(item) {
+  return `${item.contentType}/${item.slug}`;
+}
+
+// src/rules/title-rules.ts
+var TITLE_MIN_LENGTH = 30;
+var TITLE_MAX_LENGTH = 60;
+var TITLE_WARN_LENGTH = 55;
+var titleMissing = {
+  name: "title-missing",
+  severity: "error",
+  category: "seo",
+  fixStrategy: "Add a title field to the frontmatter",
+  run: (item) => {
+    if (!item.title || item.title.trim().length === 0) {
+      return [{
+        file: getDisplayPath(item),
+        field: "title",
+        rule: "title-missing",
+        severity: "error",
+        message: "Missing title",
+        suggestion: "Add a title field to the frontmatter"
+      }];
+    }
+    return [];
+  }
+};
+var titleTooShort = {
+  name: "title-too-short",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Expand the title to meet minimum length",
+  run: (item) => {
+    if (!item.title) return [];
+    const length = item.title.length;
+    if (length > 0 && length < TITLE_MIN_LENGTH) {
+      return [{
+        file: getDisplayPath(item),
+        field: "title",
+        rule: "title-too-short",
+        severity: "warning",
+        message: `Title is too short (${length}/${TITLE_MIN_LENGTH} chars minimum)`,
+        suggestion: `Expand the title to at least ${TITLE_MIN_LENGTH} characters for better SEO`
+      }];
+    }
+    return [];
+  }
+};
+var titleTooLong = {
+  name: "title-too-long",
+  severity: "error",
+  category: "seo",
+  fixStrategy: "Shorten the title to avoid truncation in search results",
+  run: (item) => {
+    if (!item.title) return [];
+    const length = item.title.length;
+    if (length > TITLE_MAX_LENGTH) {
+      return [{
+        file: getDisplayPath(item),
+        field: "title",
+        rule: "title-too-long",
+        severity: "error",
+        message: `Title is too long (${length}/${TITLE_MAX_LENGTH} chars)`,
+        suggestion: `Shorten the title to ${TITLE_MAX_LENGTH} characters or less to avoid truncation in search results`
+      }];
+    }
+    return [];
+  }
+};
+var titleApproachingLimit = {
+  name: "title-approaching-limit",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Consider shortening to leave room for site name suffix",
+  run: (item) => {
+    if (!item.title) return [];
+    const length = item.title.length;
+    if (length > TITLE_WARN_LENGTH && length <= TITLE_MAX_LENGTH) {
+      return [{
+        file: getDisplayPath(item),
+        field: "title",
+        rule: "title-approaching-limit",
+        severity: "warning",
+        message: `Title is approaching maximum length (${length}/${TITLE_MAX_LENGTH} chars)`,
+        suggestion: "Consider shortening to leave room for site name suffix in search results"
+      }];
+    }
+    return [];
+  }
+};
+var titleRules = [
+  titleMissing,
+  titleTooShort,
+  titleTooLong,
+  titleApproachingLimit
+];
+
+// src/rules/description-rules.ts
+var DESC_MIN_LENGTH = 70;
+var DESC_MAX_LENGTH = 160;
+var DESC_WARN_LENGTH = 150;
+var descriptionMissing = {
+  name: "description-missing",
+  severity: "error",
+  category: "seo",
+  fixStrategy: "Add a description field to the frontmatter (max 160 chars)",
+  run: (item) => {
+    if (!item.description || item.description.trim().length === 0) {
+      return [{
+        file: getDisplayPath(item),
+        field: "description",
+        rule: "description-missing",
+        severity: "error",
+        message: "Missing description",
+        suggestion: "Add a description field to the frontmatter (max 160 chars)"
+      }];
+    }
+    return [];
+  }
+};
+var descriptionTooLong = {
+  name: "description-too-long",
+  severity: "error",
+  category: "seo",
+  fixStrategy: "Shorten the description to avoid truncation in search results",
+  run: (item) => {
+    if (!item.description) return [];
+    const length = item.description.length;
+    if (length > DESC_MAX_LENGTH) {
+      return [{
+        file: getDisplayPath(item),
+        field: "description",
+        rule: "description-too-long",
+        severity: "error",
+        message: `Description is too long (${length}/${DESC_MAX_LENGTH} chars)`,
+        suggestion: `Shorten to ${DESC_MAX_LENGTH} characters to avoid truncation in search results`
+      }];
+    }
+    return [];
+  }
+};
+var descriptionApproachingLimit = {
+  name: "description-approaching-limit",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Consider shortening to ensure full display in search results",
+  run: (item) => {
+    if (!item.description) return [];
+    const length = item.description.length;
+    if (length > DESC_WARN_LENGTH && length <= DESC_MAX_LENGTH) {
+      return [{
+        file: getDisplayPath(item),
+        field: "description",
+        rule: "description-approaching-limit",
+        severity: "warning",
+        message: `Description is approaching maximum length (${length}/${DESC_MAX_LENGTH} chars)`,
+        suggestion: "Consider shortening to ensure full display in search results"
+      }];
+    }
+    return [];
+  }
+};
+var descriptionTooShort = {
+  name: "description-too-short",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Expand the description for better search result snippets",
+  run: (item) => {
+    if (!item.description || item.description.trim().length === 0) return [];
+    const length = item.description.length;
+    if (length < DESC_MIN_LENGTH) {
+      return [{
+        file: getDisplayPath(item),
+        field: "description",
+        rule: "description-too-short",
+        severity: "warning",
+        message: `Description is too short (${length}/${DESC_MIN_LENGTH} chars minimum)`,
+        suggestion: `Expand the description to at least ${DESC_MIN_LENGTH} characters for better search result snippets`
+      }];
+    }
+    return [];
+  }
+};
+var descriptionRules = [
+  descriptionMissing,
+  descriptionTooLong,
+  descriptionApproachingLimit,
+  descriptionTooShort
+];
+
+// src/rules/duplicate-rules.ts
+function buildDuplicateMap(items, getValue) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const value = getValue(item);
+    if (!value || value.trim().length === 0) continue;
+    const normalized = value.toLowerCase().trim();
+    const files = map.get(normalized) || [];
+    files.push(getDisplayPath(item));
+    map.set(normalized, files);
+  }
+  return map;
+}
+var duplicateTitle = {
+  name: "duplicate-title",
+  severity: "error",
+  category: "seo",
+  fixStrategy: "Use a unique title that differentiates this content from others",
+  run: (item, context) => {
+    const titleMap = buildDuplicateMap(context.allContent, (c) => c.title);
+    const normalizedTitle = item.title?.toLowerCase().trim();
+    if (!normalizedTitle) return [];
+    const filesWithSameTitle = titleMap.get(normalizedTitle);
+    if (!filesWithSameTitle || filesWithSameTitle.length <= 1) return [];
+    const otherFiles = filesWithSameTitle.filter((f) => f !== getDisplayPath(item));
+    if (otherFiles.length === 0) return [];
+    return [{
+      file: getDisplayPath(item),
+      field: "title",
+      rule: "duplicate-title",
+      severity: "error",
+      message: `Duplicate title found`,
+      suggestion: `Also used by: ${otherFiles.join(", ")}`
+    }];
+  }
+};
+var duplicateDescription = {
+  name: "duplicate-description",
+  severity: "error",
+  category: "seo",
+  fixStrategy: "Write a unique description that differentiates this content",
+  run: (item, context) => {
+    const descMap = buildDuplicateMap(context.allContent, (c) => c.description);
+    const normalizedDesc = item.description?.toLowerCase().trim();
+    if (!normalizedDesc) return [];
+    const filesWithSameDesc = descMap.get(normalizedDesc);
+    if (!filesWithSameDesc || filesWithSameDesc.length <= 1) return [];
+    const otherFiles = filesWithSameDesc.filter((f) => f !== getDisplayPath(item));
+    if (otherFiles.length === 0) return [];
+    return [{
+      file: getDisplayPath(item),
+      field: "description",
+      rule: "duplicate-description",
+      severity: "error",
+      message: `Duplicate description found`,
+      suggestion: `Also used by: ${otherFiles.join(", ")}`
+    }];
+  }
+};
+var duplicateRules = [
+  duplicateTitle,
+  duplicateDescription
+];
+
+// src/utils/heading-extractor.ts
+function isInCodeBlock(lines, lineIndex) {
+  let inCodeBlock = false;
+  for (let i = 0; i < lineIndex; i++) {
+    const line = lines[i].trim();
+    if (line.startsWith("```") || line.startsWith("~~~")) {
+      inCodeBlock = !inCodeBlock;
+    }
+  }
+  return inCodeBlock;
+}
+function extractHeadings(mdxBody) {
+  const headings = [];
+  const lines = mdxBody.split("\n");
+  const headingRegex = /^(#{1,6})\s+(.+)$/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const match = line.match(headingRegex);
+    if (match && !isInCodeBlock(lines, i)) {
+      const [, hashes, text] = match;
+      headings.push({
+        level: hashes.length,
+        text: text.trim(),
+        line: i + 1
+        // 1-indexed for display
+      });
+    }
+  }
+  return headings;
+}
+function countH1s(headings) {
+  return headings.filter((h) => h.level === 1).length;
+}
+function findH1s(headings) {
+  return headings.filter((h) => h.level === 1);
+}
+function findHierarchyViolations(headings) {
+  const violations = [];
+  let previousLevel = 0;
+  for (const heading of headings) {
+    if (heading.level > previousLevel + 1 && previousLevel > 0) {
+      violations.push({
+        heading,
+        previousLevel,
+        expectedMaxLevel: previousLevel + 1
+      });
+    }
+    previousLevel = heading.level;
+  }
+  return violations;
+}
+
+// src/rules/heading-rules.ts
+var missingH1 = {
+  name: "missing-h1",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Add an H1 heading (# Heading) at the start of the content",
+  run: (item) => {
+    if (item.contentType === "blog") {
+      return [];
+    }
+    if (item.category === "legal" || item.category === "service") {
+      return [];
+    }
+    const headings = extractHeadings(item.body);
+    const h1Count = countH1s(headings);
+    if (h1Count === 0) {
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "missing-h1",
+        severity: "warning",
+        message: "No H1 heading found in content",
+        suggestion: "Add an H1 heading (# Heading) at the start of your content"
+      }];
+    }
+    return [];
+  }
+};
+var multipleH1 = {
+  name: "multiple-h1",
+  severity: "error",
+  category: "seo",
+  fixStrategy: "Convert extra H1s to H2s",
+  run: (item) => {
+    if (item.contentType === "blog") {
+      return [];
+    }
+    const headings = extractHeadings(item.body);
+    const h1s = findH1s(headings);
+    if (h1s.length > 1) {
+      const locations = h1s.map((h) => `line ${h.line}`).join(", ");
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "multiple-h1",
+        severity: "error",
+        message: `Found ${h1s.length} H1 headings (expected 1)`,
+        suggestion: `H1 headings at: ${locations}. Convert extra H1s to H2s.`
+      }];
+    }
+    return [];
+  }
+};
+var headingHierarchySkip = {
+  name: "heading-hierarchy-skip",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Adjust heading levels to avoid skipping (e.g., H2 before H3)",
+  run: (item) => {
+    const headings = extractHeadings(item.body);
+    const violations = findHierarchyViolations(headings);
+    return violations.map((v) => ({
+      file: getDisplayPath(item),
+      field: "body",
+      rule: "heading-hierarchy-skip",
+      severity: "warning",
+      message: `Heading level skipped: H${v.previousLevel} \u2192 H${v.heading.level}`,
+      suggestion: `At line ${v.heading.line}: "${v.heading.text}". Expected H${v.expectedMaxLevel} or lower.`,
+      line: v.heading.line
+    }));
+  }
+};
+var duplicateHeadingText = {
+  name: "duplicate-heading-text",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Use unique heading text for each section",
+  run: (item) => {
+    const results = [];
+    const headings = extractHeadings(item.body);
+    const seen = /* @__PURE__ */ new Map();
+    for (const heading of headings) {
+      const normalized = heading.text.toLowerCase();
+      const previousLine = seen.get(normalized);
+      if (previousLine !== void 0) {
+        results.push({
+          file: getDisplayPath(item),
+          field: "body",
+          rule: "duplicate-heading-text",
+          severity: "warning",
+          message: `Duplicate heading text: "${heading.text}"`,
+          suggestion: `Same heading appears at line ${previousLine} and line ${heading.line}. Use unique headings for better structure.`,
+          line: heading.line
+        });
+      } else {
+        seen.set(normalized, heading.line);
+      }
+    }
+    return results;
+  }
+};
+var headingRules = [
+  missingH1,
+  multipleH1,
+  headingHierarchySkip,
+  duplicateHeadingText
+];
+
+// src/utils/image-extractor.ts
+function isInCodeBlock2(lines, lineIndex) {
+  let inCodeBlock = false;
+  for (let i = 0; i < lineIndex; i++) {
+    const line = lines[i].trim();
+    if (line.startsWith("```") || line.startsWith("~~~")) {
+      inCodeBlock = !inCodeBlock;
+    }
+  }
+  return inCodeBlock;
+}
+function extractImages(mdxBody) {
+  const images = [];
+  const lines = mdxBody.split("\n");
+  const markdownImageRegex = /!\[([^\]]*)\]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+  const jsxImageRegex = /<(?:img|Image)\s+[^>]*src=["']([^"']+)["'][^>]*>/gi;
+  const altAttrRegex = /alt=["']([^"']*)["']/i;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (isInCodeBlock2(lines, i)) {
+      continue;
+    }
+    let match;
+    while ((match = markdownImageRegex.exec(line)) !== null) {
+      const [, alt, src] = match;
+      images.push({
+        src,
+        alt: alt.trim(),
+        line: i + 1,
+        hasAlt: alt.trim().length > 0,
+        source: "inline"
+      });
+    }
+    markdownImageRegex.lastIndex = 0;
+    while ((match = jsxImageRegex.exec(line)) !== null) {
+      const [fullMatch, src] = match;
+      const altMatch = fullMatch.match(altAttrRegex);
+      const alt = altMatch ? altMatch[1] : "";
+      const alreadyCaptured = images.some(
+        (img) => img.line === i + 1 && img.src === src
+      );
+      if (!alreadyCaptured) {
+        images.push({
+          src,
+          alt: alt.trim(),
+          line: i + 1,
+          hasAlt: alt.trim().length > 0,
+          source: "inline"
+        });
+      }
+    }
+    jsxImageRegex.lastIndex = 0;
+  }
+  return images;
+}
+function normalizeImagePath(src) {
+  let normalized = src;
+  if (!normalized.startsWith("/") && !normalized.startsWith("http")) {
+    normalized = "/" + normalized;
+  }
+  normalized = normalized.split("?")[0];
+  return normalized;
+}
+
+// src/rules/image-rules.ts
+var inlineImageMissingAlt = {
+  name: "inline-image-missing-alt",
+  severity: "error",
+  category: "seo",
+  fixStrategy: "Add descriptive alt text for accessibility and SEO",
+  run: (item) => {
+    const results = [];
+    const images = extractImages(item.body);
+    for (const img of images) {
+      if (!img.hasAlt) {
+        results.push({
+          file: getDisplayPath(item),
+          field: "body",
+          rule: "inline-image-missing-alt",
+          severity: "error",
+          message: `Image missing alt text: ${img.src}`,
+          suggestion: "Add descriptive alt text for accessibility and SEO",
+          line: img.line
+        });
+      }
+    }
+    return results;
+  }
+};
+var frontmatterImageMissingAlt = {
+  name: "frontmatter-image-missing-alt",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Add an imageAlt field to the frontmatter for the featured image",
+  run: (item) => {
+    if (item.image && (!item.imageAlt || item.imageAlt.trim().length === 0)) {
+      return [{
+        file: getDisplayPath(item),
+        field: "imageAlt",
+        rule: "frontmatter-image-missing-alt",
+        severity: "warning",
+        message: "Featured image missing alt text",
+        suggestion: "Add an imageAlt field to the frontmatter for the featured image"
+      }];
+    }
+    return [];
+  }
+};
+var imageNotFound = {
+  name: "image-not-found",
+  severity: "warning",
+  category: "technical",
+  fixStrategy: "Check that the image path is correct and the file exists in public/",
+  run: (item, context) => {
+    const results = [];
+    if (item.image) {
+      const normalizedPath = normalizeImagePath(item.image);
+      if (!item.image.startsWith("http") && !isValidImagePath(normalizedPath, context.validImages)) {
+        results.push({
+          file: getDisplayPath(item),
+          field: "image",
+          rule: "image-not-found",
+          severity: "warning",
+          message: `Featured image not found: ${item.image}`,
+          suggestion: "Check that the image path is correct and the file exists in public/"
+        });
+      }
+    }
+    const images = extractImages(item.body);
+    for (const img of images) {
+      if (!img.src.startsWith("http")) {
+        const normalizedPath = normalizeImagePath(img.src);
+        if (!isValidImagePath(normalizedPath, context.validImages)) {
+          results.push({
+            file: getDisplayPath(item),
+            field: "body",
+            rule: "image-not-found",
+            severity: "warning",
+            message: `Inline image not found: ${img.src}`,
+            suggestion: "Check that the image path is correct and the file exists in public/",
+            line: img.line
+          });
+        }
+      }
+    }
+    return results;
+  }
+};
+var imageRules = [
+  inlineImageMissingAlt,
+  frontmatterImageMissingAlt,
+  imageNotFound
+];
+
+// src/utils/word-counter.ts
+function stripMarkdown(text) {
+  let result = text;
+  result = result.replace(/```[\s\S]*?```/g, "");
+  result = result.replace(/`[^`]+`/g, "");
+  result = result.replace(/!\[[^\]]*\]\([^)]+\)/g, "");
+  result = result.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+  result = result.replace(/<[^>]+>/g, "");
+  result = result.replace(/^#{1,6}\s+/gm, "");
+  result = result.replace(/\*\*([^*]+)\*\*/g, "$1");
+  result = result.replace(/\*([^*]+)\*/g, "$1");
+  result = result.replace(/__([^_]+)__/g, "$1");
+  result = result.replace(/_([^_]+)_/g, "$1");
+  result = result.replace(/^>\s+/gm, "");
+  result = result.replace(/^[-*_]{3,}$/gm, "");
+  result = result.replace(/^[\s]*[-*+]\s+/gm, "");
+  result = result.replace(/^[\s]*\d+\.\s+/gm, "");
+  result = result.replace(/^import\s+.*$/gm, "");
+  result = result.replace(/^export\s+.*$/gm, "");
+  result = result.replace(/<\w+[^>]*>[\s\S]*?<\/\w+>/g, (match) => {
+    return match.replace(/<[^>]+>/g, " ");
+  });
+  return result;
+}
+function countWords(text) {
+  const stripped = stripMarkdown(text);
+  const words = stripped.split(/\s+/).filter((word) => word.length > 0).filter((word) => /\w/.test(word));
+  return words.length;
+}
+function countSentences(text) {
+  const stripped = stripMarkdown(text);
+  const sentences = stripped.match(/[.!?]+(?:\s|$)/g);
+  return sentences ? sentences.length : 0;
+}
+
+// src/utils/readability.ts
+function estimateSyllables(word) {
+  const lower = word.toLowerCase();
+  const vowelPattern = /[aeiouyäöü]+/gi;
+  const matches = lower.match(vowelPattern);
+  if (!matches) {
+    return 1;
+  }
+  let count = matches.length;
+  if (lower.endsWith("e") && count > 1) {
+    count -= 0.5;
+  }
+  if (word.length > 12) {
+    count = Math.max(count, Math.ceil(word.length / 4));
+  }
+  return Math.max(1, Math.round(count));
+}
+function countSyllables(text) {
+  const words = text.split(/\s+/).filter((word) => word.length > 0).filter((word) => /\w/.test(word));
+  return words.reduce((total, word) => total + estimateSyllables(word), 0);
+}
+function averageWordLength(text) {
+  const words = text.split(/\s+/).filter((word) => word.length > 0).filter((word) => /\w/.test(word));
+  if (words.length === 0) return 0;
+  const totalLength = words.reduce((sum, word) => sum + word.length, 0);
+  return totalLength / words.length;
+}
+function calculateReadability(mdxBody) {
+  const plainText = stripMarkdown(mdxBody);
+  const wordCount = countWords(mdxBody);
+  const sentenceCount = countSentences(mdxBody);
+  const syllableCount = countSyllables(plainText);
+  if (wordCount === 0 || sentenceCount === 0) {
+    return {
+      score: 0,
+      avgSentenceLength: 0,
+      avgSyllablesPerWord: 0,
+      avgWordLength: 0,
+      interpretation: "No content to analyze"
+    };
+  }
+  const avgSentenceLength = wordCount / sentenceCount;
+  const avgSyllablesPerWord = syllableCount / wordCount;
+  const avgWordLen = averageWordLength(plainText);
+  const score = Math.round(180 - avgSentenceLength - 58.5 * avgSyllablesPerWord);
+  const clampedScore = Math.max(0, Math.min(100, score));
+  return {
+    score: clampedScore,
+    avgSentenceLength: Math.round(avgSentenceLength * 10) / 10,
+    avgSyllablesPerWord: Math.round(avgSyllablesPerWord * 100) / 100,
+    avgWordLength: Math.round(avgWordLen * 10) / 10,
+    interpretation: getInterpretation(clampedScore)
+  };
+}
+function getInterpretation(score) {
+  if (score >= 70) return "Very easy to read";
+  if (score >= 60) return "Easy to read";
+  if (score >= 50) return "Fairly easy to read";
+  if (score >= 40) return "Standard";
+  if (score >= 30) return "Fairly difficult";
+  if (score >= 20) return "Difficult";
+  return "Very difficult";
+}
+function isReadable(score, threshold) {
+  return score >= threshold;
+}
+
+// src/rules/content-rules.ts
+var MIN_WORD_COUNT = 300;
+var MIN_READABILITY_SCORE = 30;
+var contentTooShort = {
+  name: "content-too-short",
+  severity: "warning",
+  category: "content",
+  fixStrategy: "Expand the content for better SEO performance",
+  run: (item) => {
+    const wordCount = countWords(item.body);
+    if (wordCount < MIN_WORD_COUNT) {
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "content-too-short",
+        severity: "warning",
+        message: `Content is too short (${wordCount} words, minimum ${MIN_WORD_COUNT})`,
+        suggestion: "Consider expanding the content for better SEO performance"
+      }];
+    }
+    return [];
+  }
+};
+var lowReadability = {
+  name: "low-readability",
+  severity: "warning",
+  category: "content",
+  fixStrategy: "Use shorter sentences for easier reading",
+  run: (item) => {
+    const wordCount = countWords(item.body);
+    if (wordCount < 100) {
+      return [];
+    }
+    const readability = calculateReadability(item.body);
+    if (!isReadable(readability.score, MIN_READABILITY_SCORE)) {
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "low-readability",
+        severity: "warning",
+        message: `Low readability score (${readability.score}/100 - ${readability.interpretation})`,
+        suggestion: `Avg sentence length: ${readability.avgSentenceLength} words. Consider shorter sentences for easier reading.`
+      }];
+    }
+    return [];
+  }
+};
+var contentRules = [
+  contentTooShort,
+  lowReadability
+];
+
+// src/rules/og-rules.ts
+var blogMissingOgImage = {
+  name: "blog-missing-og-image",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Add an image field to the frontmatter for social sharing previews",
+  run: (item) => {
+    if (item.contentType !== "blog") {
+      return [];
+    }
+    if (!item.image || item.image.trim().length === 0) {
+      return [{
+        file: getDisplayPath(item),
+        field: "image",
+        rule: "blog-missing-og-image",
+        severity: "warning",
+        message: "Blog post missing featured image",
+        suggestion: "Add an image field for better social media sharing previews."
+      }];
+    }
+    return [];
+  }
+};
+var projectMissingOgImage = {
+  name: "project-missing-og-image",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Add a thumbnail image for social media sharing previews",
+  run: (item) => {
+    if (item.contentType !== "project") {
+      return [];
+    }
+    if (!item.image || item.image.trim().length === 0) {
+      return [{
+        file: getDisplayPath(item),
+        field: "image",
+        rule: "project-missing-og-image",
+        severity: "warning",
+        message: "Project missing thumbnail/featured image",
+        suggestion: "Add a thumbnail image for better social media sharing previews."
+      }];
+    }
+    return [];
+  }
+};
+var ogRules = [
+  blogMissingOgImage,
+  projectMissingOgImage
+];
+
+// src/rules/performance-rules.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var MAX_IMAGE_SIZE_KB = 500;
+var imageFileTooLarge = {
+  name: "image-file-too-large",
+  severity: "warning",
+  category: "technical",
+  fixStrategy: "Compress the image or convert to WebP/AVIF format",
+  run: (item) => {
+    const results = [];
+    const maxBytes = MAX_IMAGE_SIZE_KB * 1024;
+    const imagesToCheck = [];
+    if (item.image && !item.image.startsWith("http")) {
+      imagesToCheck.push({ src: item.image, source: "frontmatter" });
+    }
+    const inlineImages = extractImages(item.body);
+    for (const img of inlineImages) {
+      if (!img.src.startsWith("http")) {
+        imagesToCheck.push({ src: img.src, line: img.line, source: "inline" });
+      }
+    }
+    for (const image of imagesToCheck) {
+      try {
+        const imagePath = (0, import_path.join)(process.cwd(), "public", image.src);
+        const stats = (0, import_fs.statSync)(imagePath);
+        const sizeKB = Math.round(stats.size / 1024);
+        if (stats.size > maxBytes) {
+          results.push({
+            file: getDisplayPath(item),
+            field: image.source === "frontmatter" ? "image" : "body",
+            rule: "image-file-too-large",
+            severity: "warning",
+            message: `Image file too large: ${image.src} (${sizeKB}KB > ${MAX_IMAGE_SIZE_KB}KB)`,
+            suggestion: "Compress the image or convert to WebP/AVIF format to improve page load speed",
+            line: image.line
+          });
+        }
+      } catch {
+      }
+    }
+    return results;
+  }
+};
+var performanceRules = [
+  imageFileTooLarge
+];
+
+// src/rules/robots-rules.ts
+var publishedNoindex = {
+  name: "published-noindex",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Remove noindex if content should be discoverable, or set draft: true to hide it",
+  run: (item) => {
+    if (!item.draft && item.noindex === true) {
+      return [{
+        file: getDisplayPath(item),
+        field: "noindex",
+        rule: "published-noindex",
+        severity: "warning",
+        message: "Published content has noindex set \u2014 it will not appear in search results",
+        suggestion: "Remove noindex if this content should be discoverable, or set draft: true if it should be hidden entirely"
+      }];
+    }
+    return [];
+  }
+};
+var robotsRules = [
+  publishedNoindex
+];
+
+// src/rules/slug-rules.ts
+var SLUG_MAX_LENGTH = 75;
+var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var slugInvalidCharacters = {
+  name: "slug-invalid-characters",
+  severity: "error",
+  category: "seo",
+  fixStrategy: 'Use lowercase alphanumeric characters with hyphens only (e.g., "my-blog-post")',
+  run: (item) => {
+    if (!item.slug) return [];
+    const hasUppercase = /[A-Z]/.test(item.slug);
+    const matchesPattern = SLUG_PATTERN.test(item.slug);
+    if (hasUppercase || !matchesPattern) {
+      return [{
+        file: getDisplayPath(item),
+        field: "slug",
+        rule: "slug-invalid-characters",
+        severity: "error",
+        message: `Slug "${item.slug}" contains invalid characters`,
+        suggestion: 'Slugs must be lowercase alphanumeric with hyphens only (e.g., "my-blog-post")'
+      }];
+    }
+    return [];
+  }
+};
+var slugTooLong = {
+  name: "slug-too-long",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Shorten the slug for better URL readability",
+  run: (item) => {
+    if (!item.slug) return [];
+    const length = item.slug.length;
+    if (length > SLUG_MAX_LENGTH) {
+      return [{
+        file: getDisplayPath(item),
+        field: "slug",
+        rule: "slug-too-long",
+        severity: "warning",
+        message: `Slug is too long (${length}/${SLUG_MAX_LENGTH} chars)`,
+        suggestion: `Shorten the slug to ${SLUG_MAX_LENGTH} characters or less for better URL readability`
+      }];
+    }
+    return [];
+  }
+};
+var slugRules = [
+  slugInvalidCharacters,
+  slugTooLong
+];
+
+// src/rules/i18n-rules.ts
+var translationPairMissing = {
+  name: "translation-pair-missing",
+  severity: "warning",
+  category: "i18n",
+  fixStrategy: "Create the missing translation version with the same translationKey",
+  run: (item, context) => {
+    if (item.contentType === "page") return [];
+    if (!item.translationKey) return [];
+    const siblings = context.allContent.filter(
+      (c) => c.translationKey === item.translationKey && c.slug !== item.slug
+    );
+    const locales = /* @__PURE__ */ new Set([item.locale, ...siblings.map((s) => s.locale)]);
+    const results = [];
+    if (item.locale === "de" && !locales.has("en")) {
+      results.push({
+        file: getDisplayPath(item),
+        field: "translationKey",
+        rule: "translation-pair-missing",
+        severity: "warning",
+        message: `Missing English translation for translationKey "${item.translationKey}"`,
+        suggestion: "Create an English (.en.mdx) version with the same translationKey"
+      });
+    }
+    if (item.locale === "en" && !locales.has("de")) {
+      results.push({
+        file: getDisplayPath(item),
+        field: "translationKey",
+        rule: "translation-pair-missing",
+        severity: "warning",
+        message: `Missing German translation for translationKey "${item.translationKey}"`,
+        suggestion: "Create a German (.de.mdx) version with the same translationKey"
+      });
+    }
+    return results;
+  }
+};
+var missingLocale = {
+  name: "missing-locale",
+  severity: "warning",
+  category: "i18n",
+  fixStrategy: 'Add a locale field ("de" or "en") to the frontmatter',
+  run: (item) => {
+    if (item.contentType === "page") return [];
+    if (!item.locale) {
+      return [{
+        file: getDisplayPath(item),
+        field: "locale",
+        rule: "missing-locale",
+        severity: "warning",
+        message: "Missing locale field",
+        suggestion: 'Add a locale field ("de" or "en") to the frontmatter for proper i18n support'
+      }];
+    }
+    return [];
+  }
+};
+var i18nRules = [
+  translationPairMissing,
+  missingLocale
+];
+
+// src/rules/date-rules.ts
+var missingDate = {
+  name: "missing-date",
+  severity: "error",
+  category: "content",
+  fixStrategy: 'Add a date field (e.g., "2025-01-15") to the frontmatter',
+  run: (item) => {
+    if (item.contentType === "page") return [];
+    if (!item.date) {
+      return [{
+        file: getDisplayPath(item),
+        field: "date",
+        rule: "missing-date",
+        severity: "error",
+        message: "Missing date field",
+        suggestion: 'Add a date field (e.g., "2025-01-15") to the frontmatter'
+      }];
+    }
+    return [];
+  }
+};
+var futureDate = {
+  name: "future-date",
+  severity: "warning",
+  category: "content",
+  fixStrategy: "Verify the publish date is correct or set it to today",
+  run: (item) => {
+    if (!item.date) return [];
+    const dateValue = new Date(item.date);
+    const now = /* @__PURE__ */ new Date();
+    if (dateValue > now) {
+      return [{
+        file: getDisplayPath(item),
+        field: "date",
+        rule: "future-date",
+        severity: "warning",
+        message: `Date "${item.date}" is in the future`,
+        suggestion: "Verify the publish date is correct or set it to today"
+      }];
+    }
+    return [];
+  }
+};
+var missingUpdatedAt = {
+  name: "missing-updated-at",
+  severity: "warning",
+  category: "content",
+  fixStrategy: "Add an updatedAt field to help search engines identify fresh content",
+  run: (item) => {
+    if (item.contentType === "page") return [];
+    if (!item.updatedAt) {
+      return [{
+        file: getDisplayPath(item),
+        field: "updatedAt",
+        rule: "missing-updated-at",
+        severity: "warning",
+        message: "Missing updatedAt field",
+        suggestion: "Add an updatedAt field to help search engines identify fresh content"
+      }];
+    }
+    return [];
+  }
+};
+var dateRules = [
+  missingDate,
+  futureDate,
+  missingUpdatedAt
+];
+
+// src/rules/schema-rules.ts
+var blogMissingSchemaFields = {
+  name: "blog-missing-schema-fields",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Add updatedAt and image fields to frontmatter for complete schema.org data",
+  run: (item) => {
+    if (item.contentType !== "blog") {
+      return [];
+    }
+    const results = [];
+    if (!item.updatedAt) {
+      results.push({
+        file: getDisplayPath(item),
+        field: "updatedAt",
+        rule: "blog-missing-schema-fields",
+        severity: "warning",
+        message: "Missing updatedAt \u2014 BlogPosting schema dateModified will fall back to datePublished",
+        suggestion: "Add updatedAt field to frontmatter for accurate schema.org dateModified."
+      });
+    }
+    if (!item.image || item.image.trim().length === 0) {
+      results.push({
+        file: getDisplayPath(item),
+        field: "image",
+        rule: "blog-missing-schema-fields",
+        severity: "warning",
+        message: "Missing featured image \u2014 BlogPosting schema image will be empty",
+        suggestion: "Add an image field for complete BlogPosting structured data."
+      });
+    }
+    return results;
+  }
+};
+var schemaRules = [
+  blogMissingSchemaFields
+];
+
+// src/rules/keyword-coherence-rules.ts
+var MIN_SIGNIFICANT_WORDS = 2;
+var MIN_WORD_LENGTH = 3;
+var MIN_CONTENT_WORDS = 300;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  // German
+  "der",
+  "die",
+  "das",
+  "ein",
+  "eine",
+  "einer",
+  "eines",
+  "einem",
+  "einen",
+  "und",
+  "oder",
+  "aber",
+  "als",
+  "auch",
+  "auf",
+  "aus",
+  "bei",
+  "bis",
+  "f\xFCr",
+  "mit",
+  "nach",
+  "\xFCber",
+  "von",
+  "vor",
+  "wie",
+  "zum",
+  "zur",
+  "den",
+  "dem",
+  "des",
+  "ist",
+  "sind",
+  "war",
+  "hat",
+  "ihr",
+  "wir",
+  "sie",
+  "ich",
+  "nicht",
+  "sich",
+  "man",
+  "nur",
+  "noch",
+  "mehr",
+  // English
+  "the",
+  "and",
+  "for",
+  "are",
+  "but",
+  "not",
+  "you",
+  "all",
+  "can",
+  "her",
+  "was",
+  "one",
+  "our",
+  "out",
+  "has",
+  "had",
+  "its",
+  "his",
+  "how",
+  "who",
+  "what",
+  "why",
+  "when",
+  "where",
+  "which",
+  "with",
+  "this",
+  "that",
+  "from",
+  "they",
+  "been",
+  "have",
+  "will",
+  "your",
+  "into",
+  "than",
+  "them",
+  "then",
+  "some",
+  "each",
+  "make"
+]);
+function extractSignificantWords(text) {
+  return text.toLowerCase().replace(/[^\p{L}\p{N}\s-]/gu, " ").split(/\s+/).filter(
+    (word) => word.length >= MIN_WORD_LENGTH && !STOPWORDS.has(word)
+  );
+}
+function findMatchingKeywords(keywords, targetText) {
+  const normalizedTarget = targetText.toLowerCase();
+  return keywords.filter((keyword) => normalizedTarget.includes(keyword));
+}
+var keywordNotInDescription = {
+  name: "keyword-not-in-description",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Include at least one title keyword in the meta description",
+  run: (item) => {
+    if (!item.title || !item.description) return [];
+    const keywords = extractSignificantWords(item.title);
+    if (keywords.length < MIN_SIGNIFICANT_WORDS) return [];
+    const matches = findMatchingKeywords(keywords, item.description);
+    if (matches.length === 0) {
+      return [{
+        file: getDisplayPath(item),
+        field: "description",
+        rule: "keyword-not-in-description",
+        severity: "warning",
+        message: `Description contains none of the title keywords: ${keywords.join(", ")}`,
+        suggestion: "Include at least one keyword from the title in the meta description for better SEO coherence"
+      }];
+    }
+    return [];
+  }
+};
+var keywordNotInHeadings = {
+  name: "keyword-not-in-headings",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Include at least one title keyword in subheadings",
+  run: (item) => {
+    if (item.contentType !== "blog" && item.contentType !== "project") return [];
+    if (!item.title || !item.body) return [];
+    const wordCount = countWords(item.body);
+    if (wordCount < MIN_CONTENT_WORDS) return [];
+    const keywords = extractSignificantWords(item.title);
+    if (keywords.length < MIN_SIGNIFICANT_WORDS) return [];
+    const headings = extractHeadings(item.body);
+    const subHeadings = headings.filter((h) => h.level === 2 || h.level === 3);
+    if (subHeadings.length === 0) return [];
+    const allHeadingText = subHeadings.map((h) => h.text).join(" ");
+    const matches = findMatchingKeywords(keywords, allHeadingText);
+    if (matches.length === 0) {
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "keyword-not-in-headings",
+        severity: "warning",
+        message: `No title keywords found in H2/H3 headings: ${keywords.join(", ")}`,
+        suggestion: "Include at least one title keyword in your subheadings to reinforce topical relevance"
+      }];
+    }
+    return [];
+  }
+};
+var titleDescriptionNoOverlap = {
+  name: "title-description-no-overlap",
+  severity: "warning",
+  category: "seo",
+  fixStrategy: "Ensure title and description share at least one keyword",
+  run: (item) => {
+    if (!item.title || !item.description) return [];
+    const titleWords = extractSignificantWords(item.title);
+    const descWords = new Set(extractSignificantWords(item.description));
+    if (titleWords.length < MIN_SIGNIFICANT_WORDS) return [];
+    if (descWords.size < MIN_SIGNIFICANT_WORDS) return [];
+    const overlap = titleWords.filter((word) => descWords.has(word));
+    if (overlap.length === 0) {
+      return [{
+        file: getDisplayPath(item),
+        field: "description",
+        rule: "title-description-no-overlap",
+        severity: "warning",
+        message: "Title and description share no significant words",
+        suggestion: "Title and description should be thematically connected. Ensure they share at least one keyword."
+      }];
+    }
+    return [];
+  }
+};
+var keywordCoherenceRules = [
+  keywordNotInDescription,
+  keywordNotInHeadings,
+  titleDescriptionNoOverlap
+];
+
+// src/rules/link-rules.ts
+function createLinkRules(linkExtractor) {
+  const { extractLinks, getInternalLinks, isAbsoluteInternalLink } = linkExtractor;
+  const brokenInternalLink = {
+    name: "broken-internal-link",
+    severity: "error",
+    category: "technical",
+    fixStrategy: "Fix the link target to point to an existing page",
+    run: (item, context) => {
+      const results = [];
+      const links = extractLinks(item.body);
+      const internalLinks = getInternalLinks(links);
+      for (const link of internalLinks) {
+        if (!isValidInternalLink(link.url, context.validSlugs)) {
+          results.push({
+            file: getDisplayPath(item),
+            field: "body",
+            rule: "broken-internal-link",
+            severity: "error",
+            message: `Broken internal link: ${link.url}`,
+            suggestion: `Link "${link.originalUrl}" does not resolve to any known page`,
+            line: link.line
+          });
+        }
+      }
+      return results;
+    }
+  };
+  const absoluteInternalLink = {
+    name: "absolute-internal-link",
+    severity: "warning",
+    category: "technical",
+    fixStrategy: "Use a relative path instead of an absolute URL",
+    run: (item) => {
+      const results = [];
+      const links = extractLinks(item.body);
+      for (const link of links) {
+        if (link.isInternal && isAbsoluteInternalLink(link.originalUrl)) {
+          results.push({
+            file: getDisplayPath(item),
+            field: "body",
+            rule: "absolute-internal-link",
+            severity: "warning",
+            message: `Absolute internal URL: ${link.originalUrl}`,
+            suggestion: `Use relative path "${link.url}" instead for better portability`,
+            line: link.line
+          });
+        }
+      }
+      return results;
+    }
+  };
+  const draftLinkLeak = {
+    name: "draft-link-leak",
+    severity: "error",
+    category: "technical",
+    fixStrategy: "Remove or update link \u2014 the target page is not publicly visible",
+    run: (item, context) => {
+      if (item.draft || item.noindex) {
+        return [];
+      }
+      const results = [];
+      const links = extractLinks(item.body);
+      const internalLinks = getInternalLinks(links);
+      const draftPermalinks = new Set(
+        context.allContent.filter((c) => c.draft === true || c.noindex === true).map((c) => c.permalink)
+      );
+      for (const link of internalLinks) {
+        if (draftPermalinks.has(link.url)) {
+          results.push({
+            file: getDisplayPath(item),
+            field: "body",
+            rule: "draft-link-leak",
+            severity: "error",
+            message: `Internal link points to draft/noindex page: ${link.url}`,
+            suggestion: `Remove or update link "${link.originalUrl}" \u2014 the target page is not publicly visible`,
+            line: link.line
+          });
+        }
+      }
+      return results;
+    }
+  };
+  const trailingSlashInconsistency = {
+    name: "trailing-slash-inconsistency",
+    severity: "warning",
+    category: "technical",
+    fixStrategy: "Remove the trailing slash from the internal link",
+    run: (item) => {
+      const results = [];
+      const links = extractLinks(item.body);
+      const internalLinks = getInternalLinks(links);
+      for (const link of internalLinks) {
+        const originalPath = link.originalUrl.split("?")[0].split("#")[0];
+        if (originalPath !== "/" && originalPath.endsWith("/")) {
+          results.push({
+            file: getDisplayPath(item),
+            field: "body",
+            rule: "trailing-slash-inconsistency",
+            severity: "warning",
+            message: `Internal link has trailing slash: ${link.originalUrl}`,
+            suggestion: `Remove trailing slash: "${originalPath.slice(0, -1)}"`,
+            line: link.line
+          });
+        }
+      }
+      return results;
+    }
+  };
+  return [
+    brokenInternalLink,
+    absoluteInternalLink,
+    draftLinkLeak,
+    trailingSlashInconsistency
+  ];
+}
+
+// src/rules/external-link-rules.ts
+var OUTBOUND_MIN_BASE = 3;
+var OUTBOUND_WORDS_PER_EXTRA_LINK = 500;
+var OUTBOUND_MIN_WORDS_TO_APPLY = 300;
+function createExternalLinkRules(linkExtractor) {
+  const { extractLinks } = linkExtractor;
+  const externalLinkMalformed = {
+    name: "external-link-malformed",
+    severity: "warning",
+    category: "technical",
+    fixStrategy: "Check the URL for typos or missing protocol (https://)",
+    run: (item) => {
+      const results = [];
+      const links = extractLinks(item.body);
+      for (const link of links) {
+        if (link.isInternal) {
+          continue;
+        }
+        try {
+          new URL(link.url);
+        } catch {
+          results.push({
+            file: getDisplayPath(item),
+            field: "body",
+            rule: "external-link-malformed",
+            severity: "warning",
+            message: `Malformed external URL: ${link.url}`,
+            suggestion: "Check the URL for typos or missing protocol (https://)",
+            line: link.line
+          });
+        }
+      }
+      return results;
+    }
+  };
+  const externalLinkHttp = {
+    name: "external-link-http",
+    severity: "warning",
+    category: "technical",
+    fixStrategy: "Replace http:// with https://",
+    run: (item) => {
+      const results = [];
+      const links = extractLinks(item.body);
+      for (const link of links) {
+        if (link.isInternal) {
+          continue;
+        }
+        if (link.url.startsWith("http://") && !link.url.startsWith("http://localhost")) {
+          results.push({
+            file: getDisplayPath(item),
+            field: "body",
+            rule: "external-link-http",
+            severity: "warning",
+            message: `Insecure HTTP link: ${link.url}`,
+            suggestion: `Use HTTPS instead: "${link.url.replace("http://", "https://")}"`,
+            line: link.line
+          });
+        }
+      }
+      return results;
+    }
+  };
+  const externalLinkMinDensity = {
+    name: "external-link-low-density",
+    severity: "warning",
+    category: "seo",
+    fixStrategy: "Add outbound links to cite sources, reference tools, or link to studies",
+    run: (item) => {
+      if (item.contentType !== "blog") {
+        return [];
+      }
+      const wordCount = countWords(item.body);
+      if (wordCount < OUTBOUND_MIN_WORDS_TO_APPLY) {
+        return [];
+      }
+      const links = extractLinks(item.body);
+      const externalLinks = links.filter((link) => !link.isInternal);
+      const externalCount = externalLinks.length;
+      const extraLinks = Math.max(
+        0,
+        Math.floor((wordCount - OUTBOUND_MIN_WORDS_TO_APPLY) / OUTBOUND_WORDS_PER_EXTRA_LINK)
+      );
+      const requiredMin = OUTBOUND_MIN_BASE + extraLinks;
+      if (externalCount < requiredMin) {
+        return [{
+          file: getDisplayPath(item),
+          field: "body",
+          rule: "external-link-low-density",
+          severity: "warning",
+          message: `Only ${externalCount} outbound link(s) for ${wordCount} words (minimum: ${requiredMin})`,
+          suggestion: `Add ${requiredMin - externalCount} more outbound link(s) to cite sources, reference tools, or link to studies that support your claims.`
+        }];
+      }
+      return [];
+    }
+  };
+  return [
+    externalLinkMalformed,
+    externalLinkHttp,
+    externalLinkMinDensity
+  ];
+}
+
+// src/rules/orphan-rules.ts
+function normalizePermalink(permalink) {
+  if (permalink.length > 1 && permalink.endsWith("/")) {
+    return permalink.slice(0, -1);
+  }
+  return permalink;
+}
+function createOrphanRules(linkExtractor) {
+  const { extractLinks, getInternalLinks } = linkExtractor;
+  const orphanContent = {
+    name: "orphan-content",
+    severity: "warning",
+    category: "seo",
+    fixStrategy: "Add an internal link to this page from a related page",
+    run: (item, context) => {
+      if (item.contentType !== "blog" && item.contentType !== "project") {
+        return [];
+      }
+      if (item.draft || item.noindex) {
+        return [];
+      }
+      const itemPermalink = normalizePermalink(item.permalink);
+      for (const other of context.allContent) {
+        if (other.slug === item.slug && other.contentType === item.contentType) {
+          continue;
+        }
+        const links = extractLinks(other.body);
+        const internalLinks = getInternalLinks(links);
+        for (const link of internalLinks) {
+          const normalizedLink = normalizePermalink(link.url);
+          if (normalizedLink === itemPermalink) {
+            return [];
+          }
+        }
+      }
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "orphan-content",
+        severity: "warning",
+        message: `No other content links to this ${item.contentType} post`,
+        suggestion: `Add an internal link to "${item.permalink}" from a related page to improve discoverability`
+      }];
+    }
+  };
+  return [orphanContent];
+}
+
+// src/utils/geo-analyzer.ts
+var QUESTION_WORDS = [
+  "was",
+  "wie",
+  "warum",
+  "wann",
+  "wo",
+  "wer",
+  "welche",
+  "how",
+  "what",
+  "why",
+  "when",
+  "where",
+  "who",
+  "which",
+  "can",
+  "do",
+  "does",
+  "is",
+  "are",
+  "should"
+];
+var WEAK_LEAD_STARTS = [
+  "in this",
+  "the following",
+  "diesem",
+  "let's",
+  "lass uns",
+  "this section",
+  "dieser abschnitt"
+];
+var TABLE_SEPARATOR_PATTERN = /\|\s*:?-{2,}/;
+function countQuestionHeadings(body) {
+  const headings = extractHeadings(body);
+  let count = 0;
+  for (const heading of headings) {
+    const text = heading.text.trim();
+    if (text.endsWith("?")) {
+      count++;
+      continue;
+    }
+    const firstWord = text.split(/\s+/)[0]?.toLowerCase() ?? "";
+    if (QUESTION_WORDS.includes(firstWord)) {
+      count++;
+    }
+  }
+  return count;
+}
+function analyzeLeadSentences(body) {
+  const sectionPattern = /^#{2,3}\s+.+$/m;
+  const sections = body.split(sectionPattern);
+  const contentSections = sections.slice(1);
+  let totalSections = 0;
+  let sectionsWithDirectAnswers = 0;
+  for (const section of contentSections) {
+    const trimmed = section.trim();
+    if (!trimmed) continue;
+    totalSections++;
+    const sentenceMatch = trimmed.match(/^([^.!?]+[.!?])/);
+    if (!sentenceMatch) continue;
+    const firstSentence = sentenceMatch[1].trim();
+    if (firstSentence.length <= 20) continue;
+    if (firstSentence.endsWith("?")) continue;
+    const lowerSentence = firstSentence.toLowerCase();
+    const isWeakLead = WEAK_LEAD_STARTS.some(
+      (pattern) => lowerSentence.startsWith(pattern)
+    );
+    if (!isWeakLead) {
+      sectionsWithDirectAnswers++;
+    }
+  }
+  return { totalSections, sectionsWithDirectAnswers };
+}
+function countStatistics(body) {
+  const patterns = [
+    /\d+\s*%/g,
+    // Percentages: 50%, 23 %
+    /\d+(?:\.\d+)?\s*(?:x|mal|times)/gi,
+    // Multipliers: 3x, 2.5 mal, 10 times
+    /(?:€|\$|USD|EUR)\s*\d+/g,
+    // Currency: €500, $1000, USD 50
+    /\d{4,}/g,
+    // Large numbers: 10000, 2024 (4+ digits)
+    /\d+(?:\.\d+)?\s*(?:million|billion|mrd|mio)/gi
+    // Scales: 5 million, 2.3 Mrd
+  ];
+  const matches = /* @__PURE__ */ new Set();
+  for (const pattern of patterns) {
+    const found = body.matchAll(pattern);
+    for (const match of found) {
+      matches.add(`${match.index}:${match[0]}`);
+    }
+  }
+  return matches.size;
+}
+function hasFAQSection(body) {
+  const faqPattern = /#{2,3}\s*(FAQ|Häufige Fragen|Frequently Asked|Fragen und Antworten)/i;
+  return faqPattern.test(body);
+}
+function hasMarkdownTable(body) {
+  return TABLE_SEPARATOR_PATTERN.test(body);
+}
+function countEntityMentions(body, entity) {
+  const escapedEntity = entity.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(escapedEntity, "gi");
+  const matches = body.match(pattern);
+  return matches ? matches.length : 0;
+}
+function analyzeCitationBlocks(body) {
+  const h2Pattern = /^##\s+.+$/gm;
+  const h2Matches = [...body.matchAll(h2Pattern)];
+  if (h2Matches.length === 0) {
+    return { totalSections: 0, sectionsWithAdequateBlocks: 0 };
+  }
+  let totalSections = 0;
+  let sectionsWithAdequateBlocks = 0;
+  for (let i = 0; i < h2Matches.length; i++) {
+    const matchStart = h2Matches[i].index + h2Matches[i][0].length;
+    const nextHeadingStart = i + 1 < h2Matches.length ? h2Matches[i + 1].index : body.length;
+    const sectionContent = body.slice(matchStart, nextHeadingStart).trim();
+    if (!sectionContent) continue;
+    totalSections++;
+    const firstParagraph = extractFirstParagraph(sectionContent);
+    if (!firstParagraph) continue;
+    const wordCount = countWords(firstParagraph);
+    if (wordCount >= 40) {
+      sectionsWithAdequateBlocks++;
+    }
+  }
+  return { totalSections, sectionsWithAdequateBlocks };
+}
+function extractFirstParagraph(sectionContent) {
+  const lines = sectionContent.split("\n");
+  const paragraphLines = [];
+  let foundContent = false;
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (!foundContent && !trimmedLine) continue;
+    if (trimmedLine.startsWith("#")) break;
+    if (foundContent && !trimmedLine) break;
+    if (trimmedLine.startsWith("import ") || trimmedLine.startsWith("export ")) continue;
+    if (trimmedLine.startsWith("<") && !trimmedLine.startsWith("<a")) continue;
+    foundContent = true;
+    paragraphLines.push(trimmedLine);
+  }
+  return paragraphLines.join(" ");
+}
+
+// src/rules/geo-rules.ts
+var GEO_MIN_WORDS = 500;
+var FAQ_MIN_WORDS = 800;
+var QUESTION_HEADING_THRESHOLD = 0.2;
+var DIRECT_ANSWER_THRESHOLD = 0.5;
+var CITATION_WORDS_PER_STAT = 500;
+var TABLE_MIN_WORDS = 1e3;
+var ENTITY_MIN_WORDS = 800;
+var CITATION_BLOCK_MIN_WORDS = 800;
+var CITATION_BLOCK_WORD_THRESHOLD = 40;
+var CITATION_BLOCK_SECTION_THRESHOLD = 0.5;
+var geoNoQuestionHeadings = {
+  name: "geo-no-question-headings",
+  severity: "warning",
+  category: "geo",
+  fixStrategy: 'Rephrase some headings as questions (e.g., "How does X work?")',
+  run: (item) => {
+    if (item.contentType !== "blog") return [];
+    const wordCount = countWords(item.body);
+    if (wordCount < GEO_MIN_WORDS) return [];
+    const headings = extractHeadings(item.body);
+    const subHeadings = headings.filter((h) => h.level === 2 || h.level === 3);
+    if (subHeadings.length === 0) return [];
+    const questionCount = countQuestionHeadings(item.body);
+    const ratio = questionCount / subHeadings.length;
+    if (ratio < QUESTION_HEADING_THRESHOLD) {
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "geo-no-question-headings",
+        severity: "warning",
+        message: `Only ${questionCount}/${subHeadings.length} (${Math.round(ratio * 100)}%) H2/H3 headings are question-formatted \u2014 aim for at least ${Math.round(QUESTION_HEADING_THRESHOLD * 100)}%`,
+        suggestion: 'Rephrase some headings as questions (e.g., "How does X work?" / "Was ist X?") to improve LLM snippet extraction.'
+      }];
+    }
+    return [];
+  }
+};
+var geoWeakLeadSentences = {
+  name: "geo-weak-lead-sentences",
+  severity: "warning",
+  category: "geo",
+  fixStrategy: "Start each section with a concise factual sentence that directly answers the heading",
+  run: (item) => {
+    if (item.contentType !== "blog") return [];
+    const wordCount = countWords(item.body);
+    if (wordCount < GEO_MIN_WORDS) return [];
+    const { totalSections, sectionsWithDirectAnswers } = analyzeLeadSentences(item.body);
+    if (totalSections === 0) return [];
+    const ratio = sectionsWithDirectAnswers / totalSections;
+    if (ratio < DIRECT_ANSWER_THRESHOLD) {
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "geo-weak-lead-sentences",
+        severity: "warning",
+        message: `Only ${sectionsWithDirectAnswers}/${totalSections} (${Math.round(ratio * 100)}%) sections start with direct answers \u2014 aim for at least ${Math.round(DIRECT_ANSWER_THRESHOLD * 100)}%`,
+        suggestion: `Start each section with a concise factual sentence that directly answers the heading. Avoid filler like "In this section..." or "Let's look at...".`
+      }];
+    }
+    return [];
+  }
+};
+var geoLowCitationDensity = {
+  name: "geo-low-citation-density",
+  severity: "warning",
+  category: "geo",
+  fixStrategy: "Add statistics, percentages, or concrete numbers to increase citation potential",
+  run: (item) => {
+    if (item.contentType !== "blog") return [];
+    const wordCount = countWords(item.body);
+    if (wordCount < GEO_MIN_WORDS) return [];
+    const statCount = countStatistics(item.body);
+    const expectedMin = Math.floor(wordCount / CITATION_WORDS_PER_STAT);
+    if (statCount < expectedMin) {
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "geo-low-citation-density",
+        severity: "warning",
+        message: `Found ${statCount} data points but expected at least ${expectedMin} (1 per ${CITATION_WORDS_PER_STAT} words in ${wordCount}-word post)`,
+        suggestion: "Add statistics, percentages, or concrete numbers to increase citation potential in AI-generated answers."
+      }];
+    }
+    return [];
+  }
+};
+var geoMissingFaqSection = {
+  name: "geo-missing-faq-section",
+  severity: "warning",
+  category: "geo",
+  fixStrategy: 'Add an "## FAQ" or "## Frequently Asked Questions" section with Q&A pairs',
+  run: (item) => {
+    if (item.contentType !== "blog") return [];
+    const wordCount = countWords(item.body);
+    if (wordCount < FAQ_MIN_WORDS) return [];
+    if (!hasFAQSection(item.body)) {
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "geo-missing-faq-section",
+        severity: "warning",
+        message: "No FAQ section detected in long-form content",
+        suggestion: 'Add an "## FAQ" or "## H\xE4ufige Fragen" section with Q&A pairs. FAQ sections are frequently extracted by LLMs and featured in AI answers.'
+      }];
+    }
+    return [];
+  }
+};
+var geoMissingTable = {
+  name: "geo-missing-table",
+  severity: "warning",
+  category: "geo",
+  fixStrategy: "Add a comparison table, feature matrix, or data summary table",
+  run: (item) => {
+    if (item.contentType !== "blog") return [];
+    const wordCount = countWords(item.body);
+    if (wordCount < TABLE_MIN_WORDS) return [];
+    if (!hasMarkdownTable(item.body)) {
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "geo-missing-table",
+        severity: "warning",
+        message: "No data table found in long-form content (tables increase AI citation rates by 2.5x)",
+        suggestion: "Add a comparison table, feature matrix, or data summary table. Tables are highly extractable by AI systems and increase citation likelihood."
+      }];
+    }
+    return [];
+  }
+};
+var geoShortCitationBlocks = {
+  name: "geo-short-citation-blocks",
+  severity: "warning",
+  category: "geo",
+  fixStrategy: "Start each section with a 40-60 word paragraph that directly answers the heading",
+  run: (item) => {
+    if (item.contentType !== "blog") return [];
+    const wordCount = countWords(item.body);
+    if (wordCount < CITATION_BLOCK_MIN_WORDS) return [];
+    const { totalSections, sectionsWithAdequateBlocks } = analyzeCitationBlocks(item.body);
+    if (totalSections === 0) return [];
+    const ratio = sectionsWithAdequateBlocks / totalSections;
+    if (ratio < CITATION_BLOCK_SECTION_THRESHOLD) {
+      return [{
+        file: getDisplayPath(item),
+        field: "body",
+        rule: "geo-short-citation-blocks",
+        severity: "warning",
+        message: `Only ${sectionsWithAdequateBlocks}/${totalSections} sections have substantial lead paragraphs (${CITATION_BLOCK_WORD_THRESHOLD}+ words) \u2014 AI systems extract these as citation blocks`,
+        suggestion: `Start each section with a ${CITATION_BLOCK_WORD_THRESHOLD}-60 word paragraph that directly answers the heading question. These 'citation blocks' are what AI systems extract and cite.`
+      }];
+    }
+    return [];
+  }
+};
+function createGeoEntityRule(brandName, brandCity) {
+  return {
+    name: "geo-low-entity-density",
+    severity: "warning",
+    category: "geo",
+    fixStrategy: "Mention brand name and location naturally in the content body",
+    run: (item) => {
+      if (item.contentType !== "blog") return [];
+      const wordCount = countWords(item.body);
+      if (wordCount < ENTITY_MIN_WORDS) return [];
+      const results = [];
+      const displayPath = getDisplayPath(item);
+      if (brandName && countEntityMentions(item.body, brandName) === 0) {
+        results.push({
+          file: displayPath,
+          field: "body",
+          rule: "geo-low-entity-density",
+          severity: "warning",
+          message: `Brand name '${brandName}' not mentioned in content body \u2014 reduces entity recognition by AI systems`,
+          suggestion: "Mention the brand name naturally in the content to strengthen entity signals for AI systems."
+        });
+      }
+      if (brandCity && countEntityMentions(item.body, brandCity) === 0) {
+        results.push({
+          file: displayPath,
+          field: "body",
+          rule: "geo-low-entity-density",
+          severity: "warning",
+          message: `Location '${brandCity}' not mentioned in content body \u2014 reduces local entity recognition`,
+          suggestion: "Include a location reference to strengthen local entity recognition for AI search."
+        });
+      }
+      return results;
+    }
+  };
+}
+var geoStaticRules = [
+  geoNoQuestionHeadings,
+  geoWeakLeadSentences,
+  geoLowCitationDensity,
+  geoMissingFaqSection,
+  geoMissingTable,
+  geoShortCitationBlocks
+];
+function createGeoRules(geo) {
+  return [
+    ...geoStaticRules,
+    createGeoEntityRule(geo.brandName, geo.brandCity)
+  ];
+}
+
+// src/rules/category-rules.ts
+function findSuggestion(value, canonicalCategories) {
+  const lower = value.toLowerCase();
+  for (const canonical of canonicalCategories) {
+    if (canonical.toLowerCase() === lower) {
+      return canonical;
+    }
+  }
+  return void 0;
+}
+function createCategoryRules(categories) {
+  if (categories.length === 0) {
+    return [];
+  }
+  const canonicalCategories = new Set(categories);
+  const categoryInvalid = {
+    name: "category-invalid",
+    severity: "error",
+    category: "content",
+    fixStrategy: "Use a valid category from the configured list",
+    run: (item) => {
+      if (!item.categories || item.categories.length === 0) return [];
+      const results = [];
+      for (const cat of item.categories) {
+        if (!canonicalCategories.has(cat)) {
+          const suggested = findSuggestion(cat, canonicalCategories);
+          results.push({
+            file: getDisplayPath(item),
+            field: "categories",
+            rule: "category-invalid",
+            severity: "error",
+            message: `Invalid category "${cat}"`,
+            suggestion: suggested ? `Did you mean "${suggested}"? Valid categories: ${[...canonicalCategories].join(", ")}` : `Valid categories: ${[...canonicalCategories].join(", ")}`
+          });
+        }
+      }
+      return results;
+    }
+  };
+  const missingCategories = {
+    name: "missing-categories",
+    severity: "warning",
+    category: "content",
+    fixStrategy: "Add at least one category from the configured list",
+    run: (item) => {
+      if (item.contentType !== "blog") return [];
+      if (!item.categories || item.categories.length === 0) {
+        return [{
+          file: getDisplayPath(item),
+          field: "categories",
+          rule: "missing-categories",
+          severity: "warning",
+          message: "Blog post has no categories",
+          suggestion: `Add at least one category: ${[...canonicalCategories].join(", ")}`
+        }];
+      }
+      return [];
+    }
+  };
+  return [categoryInvalid, missingCategories];
+}
+
+// src/rules/canonical-rules.ts
+function createCanonicalRules(siteUrl) {
+  const canonicalMissing = {
+    name: "canonical-missing",
+    severity: "warning",
+    category: "seo",
+    fixStrategy: "Ensure the content has a valid slug so a permalink can be generated",
+    run: (item) => {
+      if (item.noindex) return [];
+      if (!item.permalink || item.permalink.trim().length === 0) {
+        return [{
+          file: getDisplayPath(item),
+          field: "permalink",
+          rule: "canonical-missing",
+          severity: "warning",
+          message: "Missing canonical URL (permalink)",
+          suggestion: "Ensure the content has a valid slug so a permalink can be generated"
+        }];
+      }
+      return [];
+    }
+  };
+  const canonicalMalformed = {
+    name: "canonical-malformed",
+    severity: "warning",
+    category: "seo",
+    fixStrategy: "Use a relative path (e.g., /blog/my-post) or absolute URL on the site domain",
+    run: (item) => {
+      if (!item.permalink || item.permalink.trim().length === 0) return [];
+      const permalink = item.permalink.trim();
+      if (permalink.startsWith("/")) return [];
+      if (permalink.startsWith(siteUrl)) return [];
+      return [{
+        file: getDisplayPath(item),
+        field: "permalink",
+        rule: "canonical-malformed",
+        severity: "warning",
+        message: `Canonical URL has unexpected format: "${permalink}"`,
+        suggestion: `Canonical should be a relative path (e.g., /blog/my-post) or absolute URL starting with ${siteUrl}`
+      }];
+    }
+  };
+  return [canonicalMissing, canonicalMalformed];
+}
+
+// src/rules/index.ts
+function buildRules(config, linkExtractor) {
+  const rules = [
+    ...titleRules,
+    ...descriptionRules,
+    ...duplicateRules,
+    ...headingRules,
+    ...createLinkRules(linkExtractor),
+    ...createExternalLinkRules(linkExtractor),
+    ...imageRules,
+    ...contentRules,
+    ...ogRules,
+    ...performanceRules,
+    ...createOrphanRules(linkExtractor),
+    ...robotsRules,
+    ...slugRules,
+    ...i18nRules,
+    ...dateRules,
+    ...config.categories.length > 0 ? createCategoryRules(config.categories) : [],
+    ...schemaRules,
+    ...createGeoRules(config.geo),
+    ...keywordCoherenceRules,
+    ...createCanonicalRules(config.siteUrl)
+  ];
+  return rules.map((rule) => applyRuleOverride(rule, config.rules));
+}
+function applyRuleOverride(rule, overrides) {
+  const override = overrides[rule.name];
+  if (!override) return rule;
+  if (override === "off") return { ...rule, run: () => [] };
+  return { ...rule, severity: override };
+}
+function runRule(rule, item, context) {
+  try {
+    return rule.run(item, context);
+  } catch (error) {
+    console.error(`Rule ${rule.name} failed on ${item.slug}:`, error);
+    return [];
+  }
+}
+function runRulesOnItem(item, context, rules) {
+  const results = [];
+  for (const rule of rules) {
+    const ruleResults = runRule(rule, item, context);
+    results.push(...ruleResults);
+  }
+  return results;
+}
+function runAllRules(items, context, rules) {
+  const results = [];
+  for (const item of items) {
+    const itemResults = runRulesOnItem(item, context, rules);
+    results.push(...itemResults);
+  }
+  return results;
+}
+
+// src/reporter.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m"
+};
+function groupByFile(results) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const result of results) {
+    const existing = grouped.get(result.file) || [];
+    existing.push(result);
+    grouped.set(result.file, existing);
+  }
+  return grouped;
+}
+function formatResult(result) {
+  const { red, yellow, dim, reset } = COLORS;
+  const icon = result.severity === "error" ? `${red}\u2717${reset}` : `${yellow}\u26A0${reset}`;
+  const ruleTag = `${dim}[${result.rule}]${reset}`;
+  let line = `    ${icon} ${ruleTag} ${result.message}`;
+  if (result.line) {
+    line += ` ${dim}(line ${result.line})${reset}`;
+  }
+  if (result.suggestion) {
+    line += `
+      ${dim}\u2192 ${result.suggestion}${reset}`;
+  }
+  return line;
+}
+function printResultsBySection(results, severity, label) {
+  const filtered = results.filter((r) => r.severity === severity);
+  if (filtered.length === 0) return;
+  const { red, yellow, bold, reset } = COLORS;
+  const color = severity === "error" ? red : yellow;
+  const grouped = groupByFile(filtered);
+  console.log(`
+${color}${bold}${label} (${filtered.length}):${reset}
+`);
+  for (const [file, fileResults] of grouped) {
+    console.log(`  ${bold}${file}${reset}`);
+    for (const result of fileResults) {
+      console.log(formatResult(result));
+    }
+    console.log("");
+  }
+}
+function printSummary(summary) {
+  const { red, yellow, green, bold, reset, dim } = COLORS;
+  console.log(`${dim}${"\u2500".repeat(50)}${reset}`);
+  console.log(`${bold}Summary:${reset}`);
+  if (summary.errors > 0) {
+    console.log(`  ${red}\u2717 ${summary.errors} error(s)${reset} ${dim}(build blocked)${reset}`);
+  }
+  if (summary.warnings > 0) {
+    console.log(`  ${yellow}\u26A0 ${summary.warnings} warning(s)${reset}`);
+  }
+  if (summary.passed > 0) {
+    console.log(`  ${green}\u2713 ${summary.passed} file(s) passed${reset}`);
+  }
+  if (summary.excluded > 0) {
+    console.log(`  ${dim}\u2298 ${summary.excluded} file(s) excluded${reset}`);
+  }
+  console.log(`
+  ${dim}Total: ${summary.total} files checked${reset}
+`);
+}
+function formatResults(results, totalFiles, excludedFiles = 0) {
+  const { bold, reset, cyan, green, dim } = COLORS;
+  const errors = results.filter((r) => r.severity === "error").length;
+  const warnings = results.filter((r) => r.severity === "warning").length;
+  const filesWithIssues = new Set(results.map((r) => r.file)).size;
+  const passed = totalFiles - filesWithIssues;
+  const summary = { errors, warnings, passed, total: totalFiles, excluded: excludedFiles };
+  console.log(`
+${cyan}${bold}GEO Lint Results${reset}`);
+  console.log(`${cyan}${"\u2550".repeat(50)}${reset}`);
+  if (results.length === 0) {
+    console.log(`
+${green}${bold}\u2713 GEO Lint: All checks passed!${reset}
+`);
+    console.log(`  ${dim}${totalFiles} files checked${reset}
+`);
+    return summary;
+  }
+  printResultsBySection(results, "error", "ERRORS");
+  printResultsBySection(results, "warning", "WARNINGS");
+  printSummary(summary);
+  return summary;
+}
+function formatResultsJson(results) {
+  return JSON.stringify(results, null, 2);
+}
+function printProgress(message) {
+  const { dim, reset } = COLORS;
+  console.log(`${dim}${message}${reset}`);
+}
+
+// src/adapters/types.ts
+function createAdapter(fn) {
+  return { loadItems: fn };
+}
+
+// src/index.ts
+async function lint(options = {}) {
+  const projectRoot = (0, import_node_path4.resolve)(options.projectRoot ?? process.cwd());
+  const config = options.config ? mergeWithDefaults(options.config) : await loadConfig(projectRoot);
+  const isPretty = (options.format ?? "pretty") === "pretty";
+  if (isPretty) printProgress("Loading content...");
+  const contentItems = options.adapter ? await options.adapter.loadItems(projectRoot) : loadContentItems(config.contentPaths, projectRoot);
+  const excludeSlugs = new Set(config.excludeSlugs);
+  const excludeCategories = new Set(config.excludeCategories);
+  const isExcluded = (item) => {
+    if (item.category && excludeCategories.has(item.category)) return true;
+    return excludeSlugs.has(item.slug);
+  };
+  const excludedItems = contentItems.filter(isExcluded);
+  const lintableItems = contentItems.filter((item) => !isExcluded(item));
+  if (isPretty) {
+    printProgress(`Loaded ${contentItems.length} content files (${excludedItems.length} excluded)`);
+    printProgress("Building validation context...");
+  }
+  const linkExtractor = createLinkExtractor(config.siteUrl);
+  const context = {
+    allContent: contentItems,
+    validSlugs: buildSlugRegistry(contentItems, config.staticRoutes, config.contentPaths),
+    validImages: buildImageRegistry(config.imageDirectories)
+  };
+  if (isPretty) {
+    printProgress(`Found ${context.validSlugs.size} valid URLs, ${context.validImages.size} images`);
+    printProgress("Running validation rules...");
+  }
+  const rules = buildRules(config, linkExtractor);
+  const results = runAllRules(lintableItems, context, rules);
+  if (options.globalRules) {
+    for (const globalRule of options.globalRules) {
+      try {
+        results.push(...globalRule.run());
+      } catch (error) {
+        if (isPretty) console.error(`Global rule ${globalRule.name} failed:`, error);
+      }
+    }
+  }
+  if (options.format === "json") {
+    console.log(formatResultsJson(results));
+  } else {
+    formatResults(results, lintableItems.length, excludedItems.length);
+  }
+  const errorCount = results.filter((r) => r.severity === "error").length;
+  return errorCount > 0 ? 1 : 0;
+}
+async function lintQuiet(options = {}) {
+  const projectRoot = (0, import_node_path4.resolve)(options.projectRoot ?? process.cwd());
+  const config = options.config ? mergeWithDefaults(options.config) : await loadConfig(projectRoot);
+  const contentItems = options.adapter ? await options.adapter.loadItems(projectRoot) : loadContentItems(config.contentPaths, projectRoot);
+  const excludeSlugs = new Set(config.excludeSlugs);
+  const excludeCategories = new Set(config.excludeCategories);
+  const isExcluded = (item) => {
+    if (item.category && excludeCategories.has(item.category)) return true;
+    return excludeSlugs.has(item.slug);
+  };
+  const lintableItems = contentItems.filter((item) => !isExcluded(item));
+  const linkExtractor = createLinkExtractor(config.siteUrl);
+  const context = {
+    allContent: contentItems,
+    validSlugs: buildSlugRegistry(contentItems, config.staticRoutes, config.contentPaths),
+    validImages: buildImageRegistry(config.imageDirectories)
+  };
+  const rules = buildRules(config, linkExtractor);
+  return runAllRules(lintableItems, context, rules);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAdapter,
+  defineConfig,
+  lint,
+  lintQuiet,
+  loadContentItems
+});
+//# sourceMappingURL=index.cjs.map