@pas7/llm-seo 0.1.6

package/dist/core/index.js

@@ -0,0 +1,1330 @@
+import * as fs from 'fs/promises';
+
+// src/core/normalize/url.ts
+function normalizePath(path, preserveTrailingSlash = false) {
+  if (!path || path === "/") {
+    return "/";
+  }
+  const hadTrailingSlash = path.endsWith("/") && path !== "/";
+  let normalized = path.startsWith("/") ? path : `/${path}`;
+  normalized = normalized.replace(/\/{2,}/g, "/");
+  const segments = [];
+  const parts = normalized.split("/");
+  for (const part of parts) {
+    if (part === "." || part === "") {
+      continue;
+    } else if (part === "..") {
+      if (segments.length > 0) {
+        segments.pop();
+      }
+    } else {
+      segments.push(part);
+    }
+  }
+  let result = "/" + segments.join("/");
+  if (preserveTrailingSlash && hadTrailingSlash && result !== "/") {
+    result += "/";
+  }
+  return result;
+}
+function joinUrlParts(...parts) {
+  if (parts.length === 0) {
+    return "/";
+  }
+  const filteredParts = parts.filter((part) => part.length > 0);
+  if (filteredParts.length === 0) {
+    return "/";
+  }
+  const joined = filteredParts.map((part) => {
+    let p = part.replace(/^\/+/, "");
+    p = p.replace(/\/+$/, "");
+    return p;
+  }).filter((p) => p.length > 0).join("/");
+  return joined.length > 0 ? `/${joined}` : "/";
+}
+function normalizeUrl(options) {
+  const { baseUrl, path, trailingSlash, stripQuery = true, stripHash = true } = options;
+  let parsedBase;
+  try {
+    parsedBase = new URL(baseUrl);
+  } catch {
+    throw new TypeError(`Invalid baseUrl: ${baseUrl}`);
+  }
+  const shouldPreserveTrailingSlash = trailingSlash === "preserve";
+  const normalizedPath = normalizePath(path, shouldPreserveTrailingSlash);
+  let finalPath = normalizedPath;
+  if (trailingSlash === "always") {
+    if (!finalPath.endsWith("/")) {
+      finalPath = `${finalPath}/`;
+    }
+  } else if (trailingSlash === "never") {
+    if (finalPath !== "/" && finalPath.endsWith("/")) {
+      finalPath = finalPath.slice(0, -1);
+    }
+  }
+  const protocol = parsedBase.protocol.toLowerCase();
+  let hostname = parsedBase.hostname.toLowerCase();
+  let port = parsedBase.port;
+  if (port) {
+    const isDefaultPort = protocol === "http:" && port === "80" || protocol === "https:" && port === "443";
+    if (!isDefaultPort) {
+      hostname = `${hostname}:${port}`;
+    }
+  }
+  let fullUrl = `${protocol}//${hostname}${finalPath}`;
+  if (!stripQuery && parsedBase.search) {
+    fullUrl += parsedBase.search;
+  }
+  if (!stripHash && parsedBase.hash) {
+    fullUrl += parsedBase.hash;
+  }
+  return fullUrl;
+}
+function sortUrls(urls) {
+  return [...urls].sort((a, b) => a.localeCompare(b));
+}
+
+// src/core/normalize/sort.ts
+function compareStrings(a, b) {
+  return a.localeCompare(b, "en", { sensitivity: "case", numeric: true });
+}
+function sortStrings(items) {
+  return [...items].sort(compareStrings);
+}
+function sortBy(items, keyFn) {
+  return [...items].sort((a, b) => compareStrings(keyFn(a), keyFn(b)));
+}
+function stableSortStrings(items) {
+  return [...items].sort((a, b) => a.localeCompare(b, "en", { sensitivity: "case", numeric: true }));
+}
+function countPathSegments(url) {
+  try {
+    const parsed = new URL(url);
+    const path = parsed.pathname.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!path) return 0;
+    return path.split("/").length;
+  } catch {
+    const cleaned = url.replace(/^\/+/, "").replace(/\/+$/, "");
+    if (!cleaned) return 0;
+    return cleaned.split("/").length;
+  }
+}
+function sortUrlsByPath(urls) {
+  return [...urls].sort((a, b) => {
+    const segmentsA = countPathSegments(a);
+    const segmentsB = countPathSegments(b);
+    if (segmentsA !== segmentsB) {
+      return segmentsA - segmentsB;
+    }
+    return a.localeCompare(b, "en", { sensitivity: "case", numeric: true });
+  });
+}
+
+// src/core/normalize/text.ts
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function normalizeLineEndings(text, lineEndings) {
+  const normalized = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  return lineEndings === "crlf" ? normalized.replace(/\n/g, "\r\n") : normalized;
+}
+function normalizeLineWhitespace(text) {
+  const lines = text.split(/\r?\n/);
+  return lines.map((line) => line.trimEnd().replace(/[ \t]+/g, (match) => " ".repeat(match.length === 0 ? 0 : match.length))).map((line) => line.replace(/  +/g, " ")).join("\n");
+}
+function normalizeSeoText(text, maxLength) {
+  const normalized = normalizeWhitespace(text);
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  const truncated = normalized.slice(0, maxLength);
+  const lastSpace = truncated.lastIndexOf(" ");
+  return lastSpace > 0 ? `${truncated.slice(0, lastSpace)}\u2026` : `${truncated.slice(0, -1)}\u2026`;
+}
+
+// src/core/canonical/locale.ts
+function selectCanonicalLocale(options) {
+  const { defaultLocale, availableLocales } = options;
+  if (!availableLocales || availableLocales.length === 0) {
+    return null;
+  }
+  const validLocales = availableLocales.filter(
+    (locale) => typeof locale === "string" && locale.length > 0
+  );
+  if (validLocales.length === 0) {
+    return null;
+  }
+  if (defaultLocale && validLocales.includes(defaultLocale)) {
+    return defaultLocale;
+  }
+  const sorted = stableSortStrings(validLocales);
+  return sorted[0] ?? null;
+}
+function localizePath(path, locale, config) {
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  if (locale === config.default && config.strategy === "subdirectory") {
+    return normalizedPath;
+  }
+  if (config.strategy === "subdirectory") {
+    return `/${locale}${normalizedPath === "/" ? "" : normalizedPath}`;
+  }
+  return normalizedPath;
+}
+function extractLocaleFromPath(path, config) {
+  if (config.strategy !== "subdirectory") {
+    return [config.default, path];
+  }
+  const match = path.match(/^\/([a-z]{2}(?:-[A-Z]{2})?)(\/|$)/);
+  if (match?.[1] && config.supported.includes(match[1])) {
+    const locale = match[1];
+    const remainingPath = path.slice(locale.length + 1) || "/";
+    return [locale, remainingPath];
+  }
+  return [config.default, path];
+}
+function generateAlternateUrls(baseUrl, path, config) {
+  const urlMap = /* @__PURE__ */ new Map();
+  for (const locale of config.supported) {
+    const localePath = localizePath(path, locale, config);
+    const fullUrl = `${baseUrl}${localePath}`;
+    urlMap.set(locale, fullUrl);
+  }
+  return urlMap;
+}
+
+// src/core/canonical/canonical-from-manifest.ts
+function generateCanonicalUrl(manifest, path, options = {}) {
+  const { trailingSlash = false, lowercase = true } = options;
+  const basePath = path.startsWith("/") ? path : `/${path}`;
+  const normalizedPath = trailingSlash ? `${basePath}${basePath.endsWith("/") ? "" : "/"}` : basePath.replace(/\/+$/, "") || "/";
+  const fullUrl = `${manifest.baseUrl}${normalizedPath}`;
+  return lowercase ? fullUrl.toLowerCase() : fullUrl;
+}
+function extractCanonicalUrls(manifest, options = {}) {
+  return manifest.pages.map((page) => generateCanonicalUrl(manifest, page.path, options));
+}
+function dedupeUrls(urls) {
+  return [...new Set(urls)];
+}
+function buildLocalePrefix(locale, strategy, defaultLocale) {
+  if (strategy === "none") {
+    return "";
+  }
+  if (strategy === "subdomain") {
+    return "";
+  }
+  if (strategy === "prefix" && locale === defaultLocale) {
+    return "";
+  }
+  return `/${locale}`;
+}
+function buildBaseUrlWithSubdomain(baseUrl, locale, strategy, defaultLocale) {
+  if (strategy !== "subdomain" || locale === defaultLocale) {
+    return baseUrl;
+  }
+  try {
+    const parsed = new URL(baseUrl);
+    return `${parsed.protocol}//${locale}.${parsed.host}`;
+  } catch {
+    return baseUrl;
+  }
+}
+function createCanonicalUrlForItem(item, options) {
+  const { baseUrl, routePrefix, defaultLocale, trailingSlash, localeStrategy } = options;
+  if (item.canonicalOverride && typeof item.canonicalOverride === "string") {
+    return item.canonicalOverride;
+  }
+  const availableLocales = item.locales ?? [defaultLocale];
+  const canonicalLocale = selectCanonicalLocale({
+    defaultLocale,
+    availableLocales
+  });
+  const locale = canonicalLocale ?? defaultLocale;
+  const localePrefix = buildLocalePrefix(locale, localeStrategy, defaultLocale);
+  const effectiveBaseUrl = buildBaseUrlWithSubdomain(baseUrl, locale, localeStrategy, defaultLocale);
+  const parts = [];
+  if (localePrefix) {
+    parts.push(localePrefix);
+  }
+  if (routePrefix) {
+    parts.push(routePrefix);
+  }
+  parts.push(item.slug);
+  const fullPath = joinUrlParts(...parts);
+  return normalizeUrl({
+    baseUrl: effectiveBaseUrl,
+    path: fullPath,
+    trailingSlash,
+    stripQuery: true,
+    stripHash: true
+  });
+}
+function createCanonicalUrlsFromManifest(options) {
+  const { items } = options;
+  if (!items || items.length === 0) {
+    return [];
+  }
+  const urls = items.map((item) => createCanonicalUrlForItem(item, options));
+  const deduped = dedupeUrls(urls);
+  return sortUrlsByPath(deduped);
+}
+
+// src/core/generate/llms-txt.ts
+function createLlmsTxt(options) {
+  const { config, canonicalUrls } = options;
+  const lineEndings = config.format?.lineEndings ?? "lf";
+  const lines = [];
+  lines.push(`# ${config.brand.name}`);
+  lines.push("");
+  if (config.brand.tagline) {
+    lines.push(`> ${config.brand.tagline}`);
+    lines.push("");
+  }
+  if (config.brand.description) {
+    lines.push(config.brand.description);
+    lines.push("");
+  }
+  const hubs = config.sections?.hubs ?? [];
+  if (hubs.length > 0) {
+    lines.push("## Sections");
+    lines.push("");
+    const sortedHubs = sortStrings(hubs);
+    for (const hub of sortedHubs) {
+      const hubLabel = getHubLabel(hub);
+      lines.push(`- [${hub}](${hub}) - ${hubLabel}`);
+    }
+    lines.push("");
+  }
+  if (canonicalUrls.length > 0) {
+    lines.push("## URLs");
+    lines.push("");
+    const sortedUrls = sortStrings(canonicalUrls);
+    for (const url of sortedUrls) {
+      lines.push(`- ${url}`);
+    }
+    lines.push("");
+  }
+  const hasPolicies = config.policy?.geoPolicy || config.policy?.citationRules || config.policy?.restrictedClaims;
+  if (hasPolicies) {
+    lines.push("## Policies");
+    lines.push("");
+    if (config.policy?.geoPolicy) {
+      lines.push(`- GEO: ${config.policy.geoPolicy}`);
+    }
+    if (config.policy?.citationRules) {
+      lines.push(`- Citations: ${config.policy.citationRules}`);
+    }
+    if (config.policy?.restrictedClaims) {
+      const status = config.policy.restrictedClaims.enable ? "Enabled" : "Disabled";
+      lines.push(`- Restricted Claims: ${status}`);
+    }
+    lines.push("");
+  }
+  const hasContact = config.contact?.email || config.contact?.social || config.contact?.phone;
+  const hasBooking = config.booking?.url;
+  if (hasContact || hasBooking) {
+    lines.push("## Contact");
+    lines.push("");
+    if (config.contact?.email) {
+      lines.push(`- Email: ${config.contact.email}`);
+    }
+    if (config.contact?.phone) {
+      lines.push(`- Phone: ${config.contact.phone}`);
+    }
+    if (config.contact?.social) {
+      if (config.contact.social.twitter) {
+        lines.push(`- Twitter: ${config.contact.social.twitter}`);
+      }
+      if (config.contact.social.linkedin) {
+        lines.push(`- LinkedIn: ${config.contact.social.linkedin}`);
+      }
+      if (config.contact.social.github) {
+        lines.push(`- GitHub: ${config.contact.social.github}`);
+      }
+    }
+    if (config.booking?.url) {
+      const label = config.booking.label ?? "Book consultation";
+      lines.push(`- Booking: ${config.booking.url} (${label})`);
+    }
+    lines.push("");
+  }
+  const hasMachineHints = config.machineHints?.robots || config.machineHints?.sitemap || config.machineHints?.llmsTxt || config.machineHints?.llmsFullTxt;
+  if (hasMachineHints) {
+    lines.push("## Machine Hints");
+    lines.push("");
+    if (config.machineHints?.robots) {
+      lines.push(`- robots.txt: ${config.machineHints.robots}`);
+    }
+    if (config.machineHints?.sitemap) {
+      lines.push(`- sitemap.xml: ${config.machineHints.sitemap}`);
+    }
+    if (config.machineHints?.llmsTxt) {
+      lines.push(`- llms.txt: ${config.machineHints.llmsTxt}`);
+    }
+    if (config.machineHints?.llmsFullTxt) {
+      lines.push(`- llms-full.txt: ${config.machineHints.llmsFullTxt}`);
+    }
+    lines.push("");
+  }
+  let content = lines.join("\n");
+  content = normalizeLineWhitespace(content);
+  content = normalizeLineEndings(content, lineEndings);
+  const finalLines = content.split(lineEndings === "crlf" ? "\r\n" : "\n");
+  return {
+    content,
+    byteSize: Buffer.byteLength(content, "utf-8"),
+    lineCount: finalLines.length
+  };
+}
+function getHubLabel(hub) {
+  const labels = {
+    "/services": "Services overview",
+    "/blog": "Blog posts",
+    "/projects": "Our projects",
+    "/cases": "Case studies",
+    "/contact": "Contact us",
+    "/about": "About us",
+    "/products": "Products",
+    "/docs": "Documentation",
+    "/faq": "Frequently asked questions",
+    "/pricing": "Pricing information",
+    "/team": "Our team",
+    "/careers": "Career opportunities",
+    "/news": "News and updates",
+    "/resources": "Resources",
+    "/support": "Support center"
+  };
+  return labels[hub] ?? formatHubLabel(hub);
+}
+function formatHubLabel(hub) {
+  const clean = hub.replace(/^\//, "");
+  return clean.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function generateLlmsTxt(manifest, _options) {
+  const canonicalUrls = manifest.pages.map((page) => `${manifest.baseUrl}${page.path}`);
+  const config = {
+    site: { baseUrl: manifest.baseUrl },
+    brand: {
+      name: manifest.title,
+      locales: ["en"],
+      ...manifest.description && { description: manifest.description }
+    },
+    manifests: {},
+    output: {
+      paths: {
+        llmsTxt: "public/llms.txt",
+        llmsFullTxt: "public/llms-full.txt"
+      }
+    }
+  };
+  return createLlmsTxt({ config, canonicalUrls }).content;
+}
+
+// src/core/generate/llms-full-txt.ts
+function createLlmsFullTxt(options) {
+  const { config, canonicalUrls, manifestItems } = options;
+  const lineEndings = config.format?.lineEndings ?? "lf";
+  const lines = [];
+  lines.push(`# ${config.brand.name} - Full LLM Context`);
+  lines.push("");
+  if (config.brand.tagline) {
+    lines.push(`> ${config.brand.tagline}`);
+    lines.push("");
+  }
+  if (config.brand.description) {
+    lines.push(config.brand.description);
+    lines.push("");
+  }
+  if (config.brand.org) {
+    lines.push(`Organization: ${config.brand.org}`);
+  }
+  lines.push(`Locales: ${config.brand.locales.join(", ")}`);
+  lines.push("");
+  if (canonicalUrls.length > 0) {
+    lines.push("## All Canonical URLs");
+    lines.push("");
+    const sortedUrls = sortStrings(canonicalUrls);
+    for (const url of sortedUrls) {
+      lines.push(`- ${url}`);
+    }
+    lines.push("");
+  }
+  const hasPolicies = config.policy?.geoPolicy || config.policy?.citationRules || config.policy?.restrictedClaims;
+  if (hasPolicies) {
+    lines.push("## Policies");
+    lines.push("");
+    if (config.policy?.geoPolicy) {
+      lines.push("### GEO Policy");
+      lines.push(config.policy.geoPolicy);
+      lines.push("");
+    }
+    if (config.policy?.citationRules) {
+      lines.push("### Citation Rules");
+      lines.push(config.policy.citationRules);
+      lines.push("");
+    }
+    if (config.policy?.restrictedClaims) {
+      lines.push("### Restricted Claims");
+      const status = config.policy.restrictedClaims.enable ? "Enabled" : "Disabled";
+      lines.push(`Status: ${status}`);
+      if (config.policy.restrictedClaims.forbidden && config.policy.restrictedClaims.forbidden.length > 0) {
+        lines.push(`Forbidden terms: ${config.policy.restrictedClaims.forbidden.join(", ")}`);
+      }
+      if (config.policy.restrictedClaims.whitelist && config.policy.restrictedClaims.whitelist.length > 0) {
+        lines.push(`Exceptions: ${config.policy.restrictedClaims.whitelist.join(", ")}`);
+      }
+      lines.push("");
+    }
+  }
+  const hasSocial = config.contact?.social?.twitter || config.contact?.social?.linkedin || config.contact?.social?.github;
+  const hasBooking = config.booking?.url;
+  if (hasSocial || hasBooking) {
+    lines.push("## Social & Booking");
+    lines.push("");
+    if (config.contact?.social?.twitter) {
+      lines.push(`- Twitter: ${config.contact.social.twitter}`);
+    }
+    if (config.contact?.social?.linkedin) {
+      lines.push(`- LinkedIn: ${config.contact.social.linkedin}`);
+    }
+    if (config.contact?.social?.github) {
+      lines.push(`- GitHub: ${config.contact.social.github}`);
+    }
+    if (config.booking?.url) {
+      const label = config.booking.label ?? "Book consultation";
+      lines.push(`- Booking: ${config.booking.url} (${label})`);
+    }
+    lines.push("");
+  }
+  const hasMachineHints = config.machineHints?.robots || config.machineHints?.sitemap || config.machineHints?.llmsTxt || config.machineHints?.llmsFullTxt;
+  if (hasMachineHints) {
+    lines.push("## Machine Hints");
+    lines.push("");
+    if (config.machineHints?.robots) {
+      lines.push(`- robots.txt: ${config.machineHints.robots}`);
+    }
+    if (config.machineHints?.sitemap) {
+      lines.push(`- sitemap.xml: ${config.machineHints.sitemap}`);
+    }
+    if (config.machineHints?.llmsTxt) {
+      lines.push(`- llms.txt: ${config.machineHints.llmsTxt}`);
+    }
+    if (config.machineHints?.llmsFullTxt) {
+      lines.push(`- llms-full.txt: ${config.machineHints.llmsFullTxt}`);
+    }
+    lines.push("");
+  }
+  const hubs = config.sections?.hubs ?? [];
+  if (hubs.length > 0 || manifestItems.length > 0) {
+    lines.push("## Sitemap");
+    lines.push("");
+    if (hubs.length > 0) {
+      const sortedHubs = sortStrings(hubs);
+      for (const hub of sortedHubs) {
+        lines.push(`- [${hub}](${hub}) - ${getHubLabel2(hub)}`);
+      }
+    }
+    if (manifestItems.length > 0) {
+      const sortedItems = sortBy(manifestItems, (item) => item.slug);
+      for (const item of sortedItems) {
+        const url = item.canonicalOverride ?? `${config.site.baseUrl}${item.slug}`;
+        const title = item.title ?? item.slug;
+        const locales = item.locales?.join(", ") ?? config.brand.locales[0] ?? "en";
+        lines.push(`- [${title}](${url}) (${locales})`);
+      }
+    }
+    lines.push("");
+  }
+  let content = lines.join("\n");
+  content = normalizeLineWhitespace(content);
+  content = normalizeLineEndings(content, lineEndings);
+  const finalLines = content.split(lineEndings === "crlf" ? "\r\n" : "\n");
+  return {
+    content,
+    byteSize: Buffer.byteLength(content, "utf-8"),
+    lineCount: finalLines.length
+  };
+}
+function getHubLabel2(hub) {
+  const labels = {
+    "/services": "Services overview",
+    "/blog": "Blog posts",
+    "/projects": "Our projects",
+    "/cases": "Case studies",
+    "/contact": "Contact us",
+    "/about": "About us",
+    "/products": "Products",
+    "/docs": "Documentation",
+    "/faq": "Frequently asked questions",
+    "/pricing": "Pricing information",
+    "/team": "Our team",
+    "/careers": "Career opportunities",
+    "/news": "News and updates",
+    "/resources": "Resources",
+    "/support": "Support center"
+  };
+  return labels[hub] ?? formatHubLabel2(hub);
+}
+function formatHubLabel2(hub) {
+  const clean = hub.replace(/^\//, "");
+  return clean.replace(/[-_]/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function generatePageContent(page, manifest, _options) {
+  const maxContentLength = _options?.maxContentLength ?? 0;
+  const lines = [];
+  const url = `${manifest.baseUrl}${page.path}`;
+  lines.push(`## ${page.title ?? page.path}`);
+  lines.push(`URL: ${url}`);
+  lines.push("");
+  if (page.description) {
+    lines.push(page.description);
+    lines.push("");
+  }
+  if (page.content) {
+    let content = page.content;
+    if (maxContentLength > 0 && content.length > maxContentLength) {
+      content = `${content.slice(0, maxContentLength)}...`;
+    }
+    lines.push(content);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function generateLlmsFullTxt(manifest, _options) {
+  const canonicalUrls = manifest.pages.map((page) => `${manifest.baseUrl}${page.path}`);
+  const manifestItems = manifest.pages.map((page) => ({
+    slug: page.path,
+    title: page.title,
+    description: page.description
+  }));
+  const config = {
+    site: { baseUrl: manifest.baseUrl },
+    brand: {
+      name: manifest.title,
+      locales: ["en"],
+      ...manifest.description && { description: manifest.description }
+    },
+    manifests: {},
+    output: {
+      paths: {
+        llmsTxt: "public/llms.txt",
+        llmsFullTxt: "public/llms-full.txt"
+      }
+    }
+  };
+  return createLlmsFullTxt({ config, canonicalUrls, manifestItems }).content;
+}
+
+// src/core/generate/citations.ts
+function createCitationsJson(options) {
+  const { config, manifestItems, sectionName, fixedTimestamp } = options;
+  const sources = manifestItems.map((item) => {
+    const url = item.canonicalOverride ?? `${config.site.baseUrl}${item.slug}`;
+    const defaultLocale = config.site.defaultLocale ?? config.brand.locales[0] ?? "en";
+    return {
+      url,
+      priority: item.priority ?? 50,
+      section: sectionName,
+      locale: item.locales?.[0] ?? defaultLocale,
+      ...item.publishedAt && { publishedAt: item.publishedAt },
+      ...item.updatedAt && { updatedAt: item.updatedAt },
+      ...item.title && { title: item.title }
+    };
+  });
+  const sortedSources = sources.sort((a, b) => {
+    if (a.priority !== b.priority) {
+      return b.priority - a.priority;
+    }
+    return a.url.localeCompare(b.url, "en", { sensitivity: "case", numeric: true });
+  });
+  const policy = {
+    restrictedClaimsEnabled: config.policy?.restrictedClaims?.enable ?? false,
+    ...config.policy?.geoPolicy && { geoPolicy: config.policy.geoPolicy },
+    ...config.policy?.citationRules && { citationRules: config.policy.citationRules }
+  };
+  return {
+    version: "1.0",
+    generated: fixedTimestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+    site: {
+      baseUrl: config.site.baseUrl,
+      name: config.brand.name
+    },
+    sources: sortedSources,
+    policy
+  };
+}
+function createCitationsJsonString(options) {
+  const citations = createCitationsJson(options);
+  return JSON.stringify(citations, null, 2);
+}
+function createCitation(page, manifest) {
+  const citation = {
+    url: `${manifest.baseUrl}${page.path}`,
+    title: page.title ?? page.path
+  };
+  if (page.description) {
+    citation.description = page.description;
+  }
+  return citation;
+}
+function citationToMarkdown(citation) {
+  if (citation.description) {
+    return `[${citation.title}](${citation.url}) - ${citation.description}`;
+  }
+  return `[${citation.title}](${citation.url})`;
+}
+function citationToJsonLd(citation) {
+  const jsonLd = {
+    "@type": "WebPage",
+    name: citation.title,
+    url: citation.url
+  };
+  if (citation.description) {
+    jsonLd.description = citation.description;
+  }
+  return jsonLd;
+}
+function generateReferenceList(citations) {
+  const lines = ["## References", ""];
+  for (let i = 0; i < citations.length; i++) {
+    const citation = citations[i];
+    if (citation) {
+      const num = i + 1;
+      lines.push(`${num}. ${citationToMarkdown(citation)}`);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/core/check/issues.ts
+function createCheckIssue(severity, code, message, path = "", context) {
+  const issue = {
+    path,
+    code,
+    message,
+    severity
+  };
+  if (context !== void 0) {
+    issue.context = context;
+  }
+  return issue;
+}
+function createIssue(overrides) {
+  return {
+    category: "content",
+    ...overrides
+  };
+}
+function groupBySeverity(issues) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const existing = grouped.get(issue.severity) ?? [];
+    existing.push(issue);
+    grouped.set(issue.severity, existing);
+  }
+  return grouped;
+}
+function groupByPage(issues) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const existing = grouped.get(issue.pageId) ?? [];
+    existing.push(issue);
+    grouped.set(issue.pageId, existing);
+  }
+  return grouped;
+}
+function filterBySeverity(issues, minSeverity) {
+  const severityOrder = ["error", "warning", "info"];
+  const minIndex = severityOrder.indexOf(minSeverity);
+  return issues.filter((issue) => {
+    const issueIndex = severityOrder.indexOf(issue.severity);
+    return issueIndex <= minIndex;
+  });
+}
+function countSeverities(issues) {
+  const counts = {
+    error: 0,
+    warning: 0,
+    info: 0
+  };
+  for (const issue of issues) {
+    counts[issue.severity]++;
+  }
+  return counts;
+}
+
+// src/core/check/rules-linter.ts
+var LINT_RULES = [
+  {
+    id: "heading-structure",
+    description: "Ensures proper heading structure (h1 -> h2 -> h3)",
+    enabled: true,
+    lint: lintHeadingStructure
+  },
+  {
+    id: "url-format",
+    description: "Validates URL format in links",
+    enabled: true,
+    lint: lintUrlFormat
+  },
+  {
+    id: "trailing-whitespace",
+    description: "Checks for trailing whitespace on lines",
+    enabled: true,
+    lint: lintTrailingWhitespace
+  },
+  {
+    id: "consistent-list-markers",
+    description: "Ensures consistent list marker usage",
+    enabled: true,
+    lint: lintListMarkers
+  }
+];
+function lintContent(content, filePath, rules = LINT_RULES.filter((r) => r.enabled)) {
+  const issues = [];
+  for (const rule of rules) {
+    const ruleIssues = rule.lint(content, filePath);
+    issues.push(...ruleIssues);
+  }
+  return {
+    filePath,
+    issues,
+    passed: issues.filter((i) => i.severity === "error").length === 0
+  };
+}
+function checkForbiddenTerms(content, forbidden, whitelist = []) {
+  const issues = [];
+  const lines = content.split("\n");
+  const whitelistLower = whitelist.map((w) => w.toLowerCase());
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const trimmed = line.trim();
+    const loweredTrimmed = trimmed.toLowerCase();
+    if (loweredTrimmed.startsWith("forbidden terms:") || loweredTrimmed.startsWith("exceptions:")) {
+      continue;
+    }
+    for (const term of forbidden) {
+      const termLower = term.toLowerCase();
+      const lineLower = line.toLowerCase();
+      if (lineLower.includes(termLower)) {
+        const isWhitelisted = whitelistLower.some(
+          (w) => lineLower.includes(w) && w.includes(termLower)
+        );
+        if (!isWhitelisted) {
+          issues.push({
+            path: "",
+            code: "forbidden_term",
+            message: `Term "${term}" is forbidden by policy`,
+            severity: "warning",
+            line: i + 1,
+            context: trimmed.substring(0, 100)
+          });
+        }
+      }
+    }
+  }
+  return issues;
+}
+function checkEmptySections(content) {
+  const issues = [];
+  const lines = content.split("\n");
+  let currentSection = null;
+  let sectionStartLine = 0;
+  let sectionHeadingLevel = 0;
+  let sectionHasContent = false;
+  let sectionWasFirst = false;
+  let isFirstHeading = true;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+    if (headingMatch?.[2]) {
+      const nextHeadingLevel = headingMatch[1]?.length ?? 0;
+      if (currentSection !== null && nextHeadingLevel > sectionHeadingLevel) {
+        sectionHasContent = true;
+      }
+      if (currentSection !== null && !sectionHasContent && !sectionWasFirst) {
+        issues.push({
+          path: "",
+          code: "empty_section",
+          message: `Section "${currentSection}" has no content`,
+          severity: "info",
+          line: sectionStartLine
+        });
+      }
+      currentSection = headingMatch[2].trim();
+      sectionStartLine = i + 1;
+      sectionHeadingLevel = nextHeadingLevel;
+      sectionHasContent = false;
+      sectionWasFirst = isFirstHeading;
+      isFirstHeading = false;
+    } else if (currentSection !== null) {
+      if (line.trim().length > 0) {
+        sectionHasContent = true;
+      }
+    }
+  }
+  if (currentSection !== null && !sectionHasContent && !sectionWasFirst) {
+    issues.push({
+      path: "",
+      code: "empty_section",
+      message: `Section "${currentSection}" has no content`,
+      severity: "info",
+      line: sectionStartLine
+    });
+  }
+  return issues;
+}
+function checkDuplicateUrls(content) {
+  const issues = [];
+  const lines = content.split("\n");
+  const seenUrls = /* @__PURE__ */ new Map();
+  const urlPattern = /\[([^\]]*)\]\(([^)]+)\)/g;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    let match = urlPattern.exec(line);
+    while (match !== null) {
+      const url = match[2];
+      if (url !== void 0) {
+        const firstOccurrence = seenUrls.get(url);
+        if (firstOccurrence !== void 0) {
+          issues.push({
+            path: "",
+            code: "duplicate_url",
+            message: `URL "${url}" appears multiple times (first at line ${firstOccurrence})`,
+            severity: "warning",
+            line: i + 1,
+            context: url
+          });
+        } else {
+          seenUrls.set(url, i + 1);
+        }
+      }
+      match = urlPattern.exec(line);
+    }
+    urlPattern.lastIndex = 0;
+  }
+  return issues;
+}
+function lintHeadingStructure(content, filePath) {
+  const issues = [];
+  const lines = content.split("\n");
+  let prevLevel = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const match = line.match(/^(#{1,6})\s/);
+    if (match?.[1]) {
+      const level = match[1].length;
+      if (level > prevLevel + 1 && prevLevel > 0) {
+        issues.push(createIssue({
+          id: "heading-skip",
+          pageId: filePath,
+          severity: "warning",
+          message: `Heading level skipped: h${prevLevel} to h${level}`,
+          line: i + 1
+        }));
+      }
+      prevLevel = level;
+    }
+  }
+  return issues;
+}
+function lintUrlFormat(content, filePath) {
+  const issues = [];
+  const lines = content.split("\n");
+  const urlPattern = /\[([^\]]*)\]\(([^)]+)\)/g;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    let match = urlPattern.exec(line);
+    while (match !== null) {
+      const url = match[2];
+      if (url && !url.startsWith("/") && !url.startsWith("http") && !url.startsWith("#")) {
+        issues.push(createIssue({
+          id: "invalid-url",
+          pageId: filePath,
+          severity: "warning",
+          message: `Invalid URL format: ${url}`,
+          line: i + 1,
+          column: match.index + 1
+        }));
+      }
+      match = urlPattern.exec(line);
+    }
+  }
+  return issues;
+}
+function lintTrailingWhitespace(content, filePath) {
+  const issues = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line !== void 0 && line.endsWith(" ")) {
+      issues.push(createIssue({
+        id: "trailing-whitespace",
+        pageId: filePath,
+        severity: "info",
+        message: "Line has trailing whitespace",
+        line: i + 1
+      }));
+    }
+  }
+  return issues;
+}
+function lintListMarkers(content, filePath) {
+  const issues = [];
+  const lines = content.split("\n");
+  const dashCount = lines.filter((l) => /^\s*-\s/.test(l)).length;
+  const asteriskCount = lines.filter((l) => /^\s*\*\s/.test(l)).length;
+  if (dashCount > 0 && asteriskCount > 0) {
+    issues.push(createIssue({
+      id: "inconsistent-list-markers",
+      pageId: filePath,
+      severity: "info",
+      message: "Mix of - and * list markers detected"
+    }));
+  }
+  return issues;
+}
+
+// src/core/check/checker.ts
+var DEFAULT_CHECKER_CONFIG = {
+  strict: false,
+  maxTitleLength: 60,
+  maxDescriptionLength: 160
+};
+function checkManifest(manifest, config = {}) {
+  const fullConfig = { ...DEFAULT_CHECKER_CONFIG, ...config };
+  const issues = [];
+  for (const page of manifest.pages) {
+    const pageIssues = checkPage(page, fullConfig);
+    issues.push(...pageIssues);
+  }
+  const summary = {
+    error: 0,
+    warning: 0,
+    info: 0
+  };
+  for (const issue of issues) {
+    summary[issue.severity]++;
+  }
+  return {
+    passed: summary.error === 0,
+    issues,
+    pagesChecked: manifest.pages.length,
+    summary
+  };
+}
+function checkPage(page, config) {
+  const issues = [];
+  const pageId = page.path;
+  if (!page.title) {
+    issues.push({
+      id: "missing-title",
+      pageId,
+      severity: "warning",
+      message: "Page is missing a title"
+    });
+  } else if (page.title.length > config.maxTitleLength) {
+    issues.push({
+      id: "title-too-long",
+      pageId,
+      severity: "warning",
+      message: `Title exceeds ${config.maxTitleLength} characters (${page.title.length})`
+    });
+  }
+  if (!page.description) {
+    issues.push({
+      id: "missing-description",
+      pageId,
+      severity: "warning",
+      message: "Page is missing a description"
+    });
+  } else if (page.description.length > config.maxDescriptionLength) {
+    issues.push({
+      id: "description-too-long",
+      pageId,
+      severity: "info",
+      message: `Description exceeds ${config.maxDescriptionLength} characters (${page.description.length})`
+    });
+  }
+  return issues;
+}
+async function checkGeneratedFiles(options) {
+  const issues = [];
+  let filesChecked = 0;
+  let filesMissing = 0;
+  let filesMismatch = 0;
+  const { config, failOn } = options;
+  const llmsTxtPath = options.llmsTxtPath ?? config.output.paths.llmsTxt;
+  const llmsFullTxtPath = options.llmsFullTxtPath ?? config.output.paths.llmsFullTxt;
+  const citationsPath = options.citationsPath ?? config.output.paths.citations;
+  const llmsTxtResult = await checkFile(llmsTxtPath);
+  if (!llmsTxtResult.exists) {
+    issues.push(createCheckIssue(
+      "error",
+      "file_missing",
+      `Required file does not exist: ${llmsTxtPath}`,
+      llmsTxtPath
+    ));
+    filesMissing++;
+  } else if (llmsTxtResult.content === "") {
+    issues.push(createCheckIssue(
+      "warning",
+      "file_empty",
+      `File is empty: ${llmsTxtPath}`,
+      llmsTxtPath
+    ));
+    filesChecked++;
+  } else {
+    filesChecked++;
+    const lintIssues = await lintFile(llmsTxtPath, llmsTxtResult.content, config);
+    issues.push(...lintIssues);
+  }
+  const llmsFullTxtResult = await checkFile(llmsFullTxtPath);
+  if (!llmsFullTxtResult.exists) {
+    issues.push(createCheckIssue(
+      "error",
+      "file_missing",
+      `Required file does not exist: ${llmsFullTxtPath}`,
+      llmsFullTxtPath
+    ));
+    filesMissing++;
+  } else if (llmsFullTxtResult.content === "") {
+    issues.push(createCheckIssue(
+      "warning",
+      "file_empty",
+      `File is empty: ${llmsFullTxtPath}`,
+      llmsFullTxtPath
+    ));
+    filesChecked++;
+  } else {
+    filesChecked++;
+    const lintIssues = await lintFile(llmsFullTxtPath, llmsFullTxtResult.content, config);
+    issues.push(...lintIssues);
+  }
+  if (citationsPath) {
+    const citationsResult = await checkFile(citationsPath);
+    if (!citationsResult.exists) {
+      issues.push(createCheckIssue(
+        "warning",
+        "file_missing",
+        `Optional citations file does not exist: ${citationsPath}`,
+        citationsPath
+      ));
+      filesMissing++;
+    } else {
+      filesChecked++;
+    }
+  }
+  const severityCounts = countSeverities(issues);
+  let exitCode;
+  if (severityCounts.error > 0) {
+    exitCode = 2;
+  } else if (failOn === "warn" && severityCounts.warning > 0) {
+    exitCode = 1;
+  } else {
+    exitCode = 0;
+  }
+  return {
+    issues,
+    summary: {
+      errors: severityCounts.error,
+      warnings: severityCounts.warning,
+      info: severityCounts.info,
+      filesChecked,
+      filesMissing,
+      filesMismatch
+    },
+    exitCode
+  };
+}
+async function checkFileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkFile(filePath) {
+  try {
+    const content = await fs.readFile(filePath, "utf-8");
+    return { exists: true, content };
+  } catch {
+    return { exists: false, content: "" };
+  }
+}
+async function readFileContent(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function compareContent(expected, actual, maxContextLines = 5) {
+  if (expected === actual) {
+    return { match: true, context: "" };
+  }
+  const expectedLines = expected.split("\n");
+  const actualLines = actual.split("\n");
+  const contextLines = [];
+  let diffCount = 0;
+  const maxLines = Math.max(expectedLines.length, actualLines.length);
+  for (let i = 0; i < maxLines && diffCount < maxContextLines; i++) {
+    const expectedLine = expectedLines[i];
+    const actualLine = actualLines[i];
+    if (expectedLine !== actualLine) {
+      diffCount++;
+      const lineNum = i + 1;
+      if (expectedLine !== void 0) {
+        contextLines.push(`Expected line ${lineNum}: "${expectedLine}"`);
+      }
+      if (actualLine !== void 0) {
+        contextLines.push(`Actual line ${lineNum}: "${actualLine}"`);
+      }
+    }
+  }
+  return {
+    match: false,
+    context: contextLines.join("\n")
+  };
+}
+async function lintFile(filePath, content, config) {
+  const issues = [];
+  const lintResult = lintContent(content, filePath);
+  for (const issue of lintResult.issues) {
+    const checkIssue = {
+      path: filePath,
+      code: issue.id,
+      message: issue.message,
+      severity: issue.severity
+    };
+    if (issue.line !== void 0) {
+      checkIssue.line = issue.line;
+    }
+    if (issue.suggestion !== void 0) {
+      checkIssue.context = issue.suggestion;
+    }
+    issues.push(checkIssue);
+  }
+  if (config.policy?.restrictedClaims?.enable) {
+    const forbidden = config.policy.restrictedClaims.forbidden ?? [];
+    const whitelist = config.policy.restrictedClaims.whitelist ?? [];
+    const forbiddenIssues = checkForbiddenTerms(content, forbidden, whitelist);
+    for (const issue of forbiddenIssues) {
+      const checkIssue = {
+        path: filePath,
+        code: "forbidden_term",
+        message: issue.message,
+        severity: issue.severity
+      };
+      if (issue.line !== void 0) {
+        checkIssue.line = issue.line;
+      }
+      if (issue.context !== void 0) {
+        checkIssue.context = issue.context;
+      }
+      issues.push(checkIssue);
+    }
+  }
+  const emptySectionIssues = checkEmptySections(content);
+  for (const issue of emptySectionIssues) {
+    const checkIssue = {
+      path: filePath,
+      code: "empty_section",
+      message: issue.message,
+      severity: issue.severity
+    };
+    if (issue.line !== void 0) {
+      checkIssue.line = issue.line;
+    }
+    if (issue.context !== void 0) {
+      checkIssue.context = issue.context;
+    }
+    issues.push(checkIssue);
+  }
+  const duplicateUrlIssues = checkDuplicateUrls(content);
+  for (const issue of duplicateUrlIssues) {
+    const checkIssue = {
+      path: filePath,
+      code: "duplicate_url",
+      message: issue.message,
+      severity: issue.severity
+    };
+    if (issue.line !== void 0) {
+      checkIssue.line = issue.line;
+    }
+    if (issue.context !== void 0) {
+      checkIssue.context = issue.context;
+    }
+    issues.push(checkIssue);
+  }
+  return issues;
+}
+async function checkFilesAgainstExpected(llmsTxtPath, expectedLlmsTxt, llmsFullTxtPath, expectedLlmsFullTxt, maxContextLines = 5) {
+  const issues = [];
+  const llmsTxtContent = await readFileContent(llmsTxtPath);
+  if (llmsTxtContent === null) {
+    issues.push(createCheckIssue(
+      "error",
+      "file_missing",
+      `Required file does not exist: ${llmsTxtPath}`,
+      llmsTxtPath
+    ));
+  } else if (llmsTxtContent === "") {
+    issues.push(createCheckIssue(
+      "warning",
+      "file_empty",
+      `File is empty: ${llmsTxtPath}`,
+      llmsTxtPath
+    ));
+  } else {
+    const compareResult = compareContent(expectedLlmsTxt, llmsTxtContent, maxContextLines);
+    if (!compareResult.match) {
+      issues.push(createCheckIssue(
+        "error",
+        "file_mismatch",
+        `Content differs from expected output`,
+        llmsTxtPath,
+        compareResult.context
+      ));
+    }
+  }
+  const llmsFullTxtContent = await readFileContent(llmsFullTxtPath);
+  if (llmsFullTxtContent === null) {
+    issues.push(createCheckIssue(
+      "error",
+      "file_missing",
+      `Required file does not exist: ${llmsFullTxtPath}`,
+      llmsFullTxtPath
+    ));
+  } else if (llmsFullTxtContent === "") {
+    issues.push(createCheckIssue(
+      "warning",
+      "file_empty",
+      `File is empty: ${llmsFullTxtPath}`,
+      llmsFullTxtPath
+    ));
+  } else {
+    const compareResult = compareContent(expectedLlmsFullTxt, llmsFullTxtContent, maxContextLines);
+    if (!compareResult.match) {
+      issues.push(createCheckIssue(
+        "error",
+        "file_mismatch",
+        `Content differs from expected output`,
+        llmsFullTxtPath,
+        compareResult.context
+      ));
+    }
+  }
+  return issues;
+}
+
+export { DEFAULT_CHECKER_CONFIG, LINT_RULES, checkFileExists, checkFilesAgainstExpected, checkGeneratedFiles, checkManifest, citationToJsonLd, citationToMarkdown, compareContent, compareStrings, createCanonicalUrlForItem, createCanonicalUrlsFromManifest, createCitation, createCitationsJson, createCitationsJsonString, createIssue, createLlmsFullTxt, createLlmsTxt, dedupeUrls, extractCanonicalUrls, extractLocaleFromPath, filterBySeverity, generateAlternateUrls, generateCanonicalUrl, generateLlmsFullTxt, generateLlmsTxt, generatePageContent, generateReferenceList, groupByPage, groupBySeverity, lintContent, localizePath, normalizeLineEndings, normalizeLineWhitespace, normalizeSeoText, normalizeUrl, normalizeWhitespace, readFileContent, sortBy, sortStrings, sortUrls };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map