@pas7/llm-seo 0.1.6

package/dist/cli/bin.js

@@ -0,0 +1,2232 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import * as fs from 'fs/promises';
+import { writeFile, rename, unlink, readFile, mkdir } from 'fs/promises';
+import { resolve, dirname, basename, join, extname } from 'path';
+import { randomBytes } from 'crypto';
+import { existsSync } from 'fs';
+import { pathToFileURL } from 'url';
+import { Command } from 'commander';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli/exit-codes.ts
+var ExitCodes;
+var init_exit_codes = __esm({
+  "src/cli/exit-codes.ts"() {
+    ExitCodes = {
+      /** Command completed successfully */
+      OK: 0,
+      /** Warnings found (when --fail-on warn) */
+      WARN: 1,
+      /** Errors found */
+      ERROR: 2,
+      /** Network error (for doctor command) */
+      NETWORK_ERROR: 3,
+      /** Configuration file not found */
+      CONFIG_NOT_FOUND: 4,
+      /** Invalid configuration */
+      INVALID_CONFIG: 5,
+      /** File not found */
+      FILE_NOT_FOUND: 6,
+      /** Validation failed */
+      VALIDATION_FAILED: 7,
+      /** Generation failed */
+      GENERATION_FAILED: 8,
+      /** Permission denied */
+      PERMISSION_DENIED: 126,
+      /** Command not found */
+      COMMAND_NOT_FOUND: 127
+    };
+  }
+});
+var SiteConfigSchema, BrandConfigSchema, SectionsConfigSchema, SocialConfigSchema, ContactConfigSchema, RestrictedClaimsConfigSchema, PolicyConfigSchema, BookingConfigSchema, MachineHintsConfigSchema, OutputPathsConfigSchema, OutputConfigSchema, FormatConfigSchema, LlmsSeoConfigSchema, ConfigSchema, LocaleConfigSchema, CheckConfigSchema;
+var init_config_schema = __esm({
+  "src/schema/config.schema.ts"() {
+    SiteConfigSchema = z.object({
+      /** Site base URL - must be valid URL with http/https, no trailing slash */
+      baseUrl: z.string().url({ message: "Must be a valid URL with http or https protocol" }).refine(
+        (url) => !url.endsWith("/"),
+        { message: "Base URL must not have a trailing slash" }
+      ),
+      /** Default locale - must be in locales if provided */
+      defaultLocale: z.string().min(2).optional()
+    });
+    BrandConfigSchema = z.object({
+      /** Brand name - required */
+      name: z.string().min(1, { message: "Brand name is required" }),
+      /** Optional tagline */
+      tagline: z.string().optional(),
+      /** Optional description */
+      description: z.string().optional(),
+      /** Optional organization name */
+      org: z.string().optional(),
+      /** Supported locales - e.g., ["en", "uk", "de"] */
+      locales: z.array(z.string().min(2)).min(1, { message: "At least one locale is required" })
+    });
+    SectionsConfigSchema = z.object({
+      /** Hub paths - e.g., ["/services", "/blog", "/projects"] */
+      hubs: z.array(z.string()).default([])
+    });
+    SocialConfigSchema = z.object({
+      /** Twitter handle or URL */
+      twitter: z.string().optional(),
+      /** LinkedIn URL */
+      linkedin: z.string().optional(),
+      /** GitHub URL */
+      github: z.string().optional()
+    });
+    ContactConfigSchema = z.object({
+      /** Contact email */
+      email: z.string().email().optional(),
+      /** Social links */
+      social: SocialConfigSchema.optional(),
+      /** Phone number */
+      phone: z.string().optional()
+    });
+    RestrictedClaimsConfigSchema = z.object({
+      /** Enable restricted claims checking */
+      enable: z.boolean(),
+      /** Forbidden words/phrases - e.g., ["best", "#1", "guaranteed"] */
+      forbidden: z.array(z.string()).optional(),
+      /** Allowlisted phrases */
+      whitelist: z.array(z.string()).optional()
+    });
+    PolicyConfigSchema = z.object({
+      /** Geographic policy statement */
+      geoPolicy: z.string().optional(),
+      /** Citation rules */
+      citationRules: z.string().optional(),
+      /** Restricted claims configuration */
+      restrictedClaims: RestrictedClaimsConfigSchema.optional()
+    });
+    BookingConfigSchema = z.object({
+      /** Booking URL - e.g., Cal.com link */
+      url: z.string().url().optional(),
+      /** Booking label - e.g., "Book a consultation" */
+      label: z.string().optional()
+    });
+    MachineHintsConfigSchema = z.object({
+      /** URL to robots.txt */
+      robots: z.string().url().optional(),
+      /** URL to sitemap.xml */
+      sitemap: z.string().url().optional(),
+      /** URL to llms.txt */
+      llmsTxt: z.string().url().optional(),
+      /** URL to llms-full.txt */
+      llmsFullTxt: z.string().url().optional()
+    });
+    OutputPathsConfigSchema = z.object({
+      /** Path to llms.txt output - e.g., "public/llms.txt" */
+      llmsTxt: z.string().min(1, { message: "llmsTxt output path is required" }),
+      /** Path to llms-full.txt output - e.g., "public/llms-full.txt" */
+      llmsFullTxt: z.string().min(1, { message: "llmsFullTxt output path is required" }),
+      /** Path to citations.json output - e.g., "public/citations.json" */
+      citations: z.string().optional()
+    });
+    OutputConfigSchema = z.object({
+      /** Output paths */
+      paths: OutputPathsConfigSchema
+    });
+    FormatConfigSchema = z.object({
+      /** Trailing slash handling */
+      trailingSlash: z.enum(["always", "never", "preserve"]).default("never"),
+      /** Line endings format */
+      lineEndings: z.enum(["lf", "crlf"]).default("lf"),
+      /** Locale URL strategy */
+      localeStrategy: z.enum(["prefix", "subdomain", "none"]).optional()
+    });
+    LlmsSeoConfigSchema = z.object({
+      /** Site configuration */
+      site: SiteConfigSchema,
+      /** Brand configuration */
+      brand: BrandConfigSchema,
+      /** Sections configuration */
+      sections: SectionsConfigSchema.optional(),
+      /** Manifests configuration */
+      manifests: z.record(z.unknown()).default({}),
+      /** Contact configuration */
+      contact: ContactConfigSchema.optional(),
+      /** Policy configuration */
+      policy: PolicyConfigSchema.optional(),
+      /** Booking configuration */
+      booking: BookingConfigSchema.optional(),
+      /** Machine hints configuration */
+      machineHints: MachineHintsConfigSchema.optional(),
+      /** Output configuration */
+      output: OutputConfigSchema,
+      /** Format configuration */
+      format: FormatConfigSchema.optional()
+    });
+    ConfigSchema = z.object({
+      baseUrl: z.string().url(),
+      title: z.string().min(1),
+      description: z.string().optional(),
+      outputDir: z.string().default("./public"),
+      includeOptionalSections: z.boolean().default(false),
+      maxContentLength: z.number().int().nonnegative().default(0)
+    });
+    LocaleConfigSchema = z.object({
+      default: z.string().min(2),
+      supported: z.array(z.string().min(2)).min(1),
+      strategy: z.enum(["subdirectory", "subdomain", "domain"])
+    });
+    CheckConfigSchema = z.object({
+      strict: z.boolean().default(false),
+      maxTitleLength: z.number().int().positive().default(60),
+      maxDescriptionLength: z.number().int().positive().default(160),
+      enableLint: z.boolean().default(true)
+    });
+    z.object({
+      site: ConfigSchema,
+      locale: LocaleConfigSchema.optional(),
+      check: CheckConfigSchema.optional()
+    });
+  }
+});
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function readFileSafe(filePath) {
+  try {
+    return await readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+async function writeFileAtomic(filePath, content) {
+  const dir = dirname(filePath);
+  await ensureDir(dir);
+  const uniqueId = randomBytes(8).toString("hex");
+  const baseName = basename(filePath);
+  const tempPath = join(dir, `.tmp-${uniqueId}-${baseName}`);
+  try {
+    await writeFile(tempPath, content, "utf-8");
+    await rename(tempPath, filePath);
+  } catch (error) {
+    try {
+      await unlink(tempPath);
+    } catch {
+    }
+    throw error;
+  }
+}
+var init_fs = __esm({
+  "src/cli/io/fs.ts"() {
+  }
+});
+function findConfigFile(cwd = process.cwd()) {
+  for (const fileName of CONFIG_FILE_NAMES) {
+    const filePath = resolve(cwd, fileName);
+    if (existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function getConfigFileType(filePath) {
+  const ext = extname(filePath);
+  if (ext === ".ts") return "ts";
+  if (ext === ".js") return "js";
+  return "json";
+}
+async function importConfigModule(configPath) {
+  const absolutePath = resolve(configPath);
+  const fileUrl = pathToFileURL(absolutePath).href;
+  const module = await import(fileUrl);
+  const config = module.default ?? module;
+  return config;
+}
+function parseConfig(rawConfig, configPath) {
+  const issues = [];
+  const result = LlmsSeoConfigSchema.safeParse(rawConfig);
+  if (!result.success) {
+    const errorMessages = result.error.issues.map((e) => {
+      const path = e.path.join(".");
+      return `${path}: ${e.message}`;
+    }).join("; ");
+    throw new Error(`Invalid config at ${configPath}: ${errorMessages}`);
+  }
+  return { config: result.data, issues };
+}
+async function loadConfig(options) {
+  const { path: configPath } = options;
+  const absolutePath = resolve(configPath);
+  if (!existsSync(absolutePath)) {
+    throw new Error(`Config file not found: ${absolutePath}`);
+  }
+  const fileType = getConfigFileType(absolutePath);
+  let rawConfig;
+  if (fileType === "json") {
+    const content = await readFileSafe(absolutePath);
+    if (content === null) {
+      throw new Error(`Failed to read config file: ${absolutePath}`);
+    }
+    try {
+      rawConfig = JSON.parse(content);
+    } catch {
+      throw new Error(`Failed to parse JSON config: ${absolutePath}`);
+    }
+  } else {
+    try {
+      rawConfig = await importConfigModule(absolutePath);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to import config module: ${absolutePath}
+${message}`);
+    }
+  }
+  const { config, issues } = parseConfig(rawConfig, absolutePath);
+  return {
+    config,
+    issues,
+    configPath: absolutePath
+  };
+}
+var CONFIG_FILE_NAMES;
+var init_load_config = __esm({
+  "src/cli/io/load-config.ts"() {
+    init_config_schema();
+    init_fs();
+    CONFIG_FILE_NAMES = [
+      "llm-seo.config.ts",
+      "llm-seo.config.js",
+      "llm-seo.config.json"
+    ];
+  }
+});
+
+// src/cli/io/report.ts
+function shouldUseColors() {
+  return process.env.NO_COLOR === void 0 && process.stdout.isTTY === true;
+}
+function color(text, colorCode) {
+  if (!shouldUseColors()) {
+    return text;
+  }
+  return `${colors[colorCode]}${text}${colors.reset}`;
+}
+function printError(message) {
+  console.error(color("[ERROR]", "red"), message);
+}
+function printWarning(message) {
+  console.warn(color("[WARN]", "yellow"), message);
+}
+function printInfo(message) {
+  console.log(color("[INFO]", "blue"), message);
+}
+function printVerbose(message) {
+  console.log(color("  [debug]", "gray"), message);
+}
+function printHeader(title) {
+  console.log("");
+  console.log(color(title, "bold"));
+  console.log("-".repeat(title.length));
+}
+function printCheckReport(result, verbose) {
+  console.log("");
+  printHeader("SEO Check Results");
+  const { summary, issues } = result;
+  console.log("");
+  console.log(`Files checked: ${summary.filesChecked}`);
+  console.log(`Files missing: ${summary.filesMissing}`);
+  console.log(`Files with issues: ${summary.filesMismatch}`);
+  console.log("");
+  console.log("Summary:");
+  const errorText = summary.errors > 0 ? color(`${summary.errors} error${summary.errors !== 1 ? "s" : ""}`, "red") : `${summary.errors} errors`;
+  const warningText = summary.warnings > 0 ? color(`${summary.warnings} warning${summary.warnings !== 1 ? "s" : ""}`, "yellow") : `${summary.warnings} warnings`;
+  const infoText = summary.info > 0 ? color(`${summary.info} info`, "blue") : `${summary.info} info`;
+  console.log(`  ${errorText}, ${warningText}, ${infoText}`);
+  if (issues.length > 0) {
+    console.log("");
+    printHeader("Issues");
+    const issuesByFile = groupIssuesByFile(issues);
+    for (const [filePath, fileIssues] of issuesByFile) {
+      console.log("");
+      console.log(color(filePath, "cyan"));
+      for (const issue of fileIssues) {
+        printCheckIssue(issue, verbose);
+      }
+    }
+  }
+  console.log("");
+  if (summary.errors > 0) {
+    console.log(color("FAILED", "red"), "- Errors found");
+  } else if (summary.warnings > 0) {
+    console.log(color("PASSED WITH WARNINGS", "yellow"));
+  } else {
+    console.log(color("PASSED", "green"));
+  }
+  console.log("");
+}
+function printCheckIssue(issue, verbose) {
+  const severityIcon = issue.severity === "error" ? color("[ERROR]", "red") : issue.severity === "warning" ? color("[WARN]", "yellow") : color("[INFO]", "blue");
+  const lineInfo = issue.line !== void 0 ? `:${issue.line}` : "";
+  const prefix = `  ${severityIcon} ${issue.path}${lineInfo}`;
+  console.log(`${prefix}: ${issue.message}`);
+  if (verbose && issue.context) {
+    console.log(color(`    Context: "${issue.context}"`, "gray"));
+  }
+}
+function groupIssuesByFile(issues) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const issue of issues) {
+    const existing = grouped.get(issue.path) ?? [];
+    existing.push(issue);
+    grouped.set(issue.path, existing);
+  }
+  return grouped;
+}
+function printGenerateReport(files, verbose) {
+  console.log("");
+  printHeader("Generation Complete");
+  console.log("");
+  console.log(`Generated ${files.length} file${files.length !== 1 ? "s" : ""}:`);
+  for (const file of files) {
+    const sizeStr = formatBytes(file.size);
+    console.log(`  ${color("[OK]", "green")} ${file.path} (${sizeStr})`);
+    if (verbose) {
+      console.log(color(`    Size: ${file.size} bytes`, "gray"));
+    }
+  }
+  const totalSize = files.reduce((sum, f) => sum + f.size, 0);
+  console.log("");
+  console.log(`Total size: ${formatBytes(totalSize)}`);
+  console.log("");
+}
+function printDoctorReport(checks, verbose) {
+  console.log("");
+  printHeader("Diagnostic Results");
+  console.log("");
+  for (const check of checks) {
+    printDoctorCheck(check, verbose);
+  }
+  console.log("");
+  const errors = checks.filter((c) => c.status === "error").length;
+  const warnings = checks.filter((c) => c.status === "warn").length;
+  const ok = checks.filter((c) => c.status === "ok").length;
+  const skipped = checks.filter((c) => c.status === "skip").length;
+  console.log(
+    `${color("[OK]", "green")} ${ok} ok, ${color("[WARN]", "yellow")} ${warnings} warning${warnings !== 1 ? "s" : ""}, ${color("[ERROR]", "red")} ${errors} error${errors !== 1 ? "s" : ""}` + (skipped > 0 ? `, ${skipped} skipped` : "")
+  );
+  console.log("");
+}
+function printDoctorCheck(check, verbose) {
+  const icon = check.status === "ok" ? color("[OK]", "green") : check.status === "warn" ? color("[WARN]", "yellow") : check.status === "error" ? color("[ERROR]", "red") : color("[SKIP]", "gray");
+  const timeStr = check.responseTime !== void 0 ? ` (${check.responseTime}ms)` : "";
+  console.log(`${icon} ${check.name}: ${check.message}${timeStr}`);
+  if (verbose) {
+    console.log(color(`  URL: ${check.url}`, "gray"));
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const units = ["B", "KB", "MB", "GB"];
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  const size = bytes / Math.pow(k, i);
+  if (i === 0) {
+    return `${bytes} B`;
+  }
+  const unit = units[i] ?? "B";
+  return `${size.toFixed(1)} ${unit}`;
+}
+function printDryRunHeader(fileName) {
+  console.log("");
+  console.log(color(`--- ${fileName} ---`, "cyan"));
+}
+function printSeparator() {
+  console.log(color("-".repeat(60), "gray"));
+}
+var colors;
+var init_report = __esm({
+  "src/cli/io/report.ts"() {
+    colors = {
+      reset: "\x1B[0m",
+      red: "\x1B[31m",
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      blue: "\x1B[34m",
+      cyan: "\x1B[36m",
+      gray: "\x1B[90m",
+      bold: "\x1B[1m"
+    };
+  }
+});
+
+// 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;
+}
+var init_url = __esm({
+  "src/core/normalize/url.ts"() {
+  }
+});
+
+// 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 });
+  });
+}
+var init_sort = __esm({
+  "src/core/normalize/sort.ts"() {
+  }
+});
+
+// src/core/normalize/text.ts
+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");
+}
+var init_text = __esm({
+  "src/core/normalize/text.ts"() {
+  }
+});
+
+// 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;
+}
+var init_locale = __esm({
+  "src/core/canonical/locale.ts"() {
+    init_sort();
+  }
+});
+
+// src/core/canonical/canonical-from-manifest.ts
+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);
+}
+var init_canonical_from_manifest = __esm({
+  "src/core/canonical/canonical-from-manifest.ts"() {
+    init_url();
+    init_sort();
+    init_locale();
+  }
+});
+
+// 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());
+}
+var init_llms_txt = __esm({
+  "src/core/generate/llms-txt.ts"() {
+    init_sort();
+    init_text();
+  }
+});
+
+// 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());
+}
+var init_llms_full_txt = __esm({
+  "src/core/generate/llms-full-txt.ts"() {
+    init_sort();
+    init_text();
+  }
+});
+
+// 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);
+}
+var init_citations = __esm({
+  "src/core/generate/citations.ts"() {
+  }
+});
+
+// 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 countSeverities(issues) {
+  const counts = {
+    error: 0,
+    warning: 0,
+    info: 0
+  };
+  for (const issue of issues) {
+    counts[issue.severity]++;
+  }
+  return counts;
+}
+var init_issues = __esm({
+  "src/core/check/issues.ts"() {
+  }
+});
+
+// src/core/check/rules-linter.ts
+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;
+}
+var LINT_RULES;
+var init_rules_linter = __esm({
+  "src/core/check/rules-linter.ts"() {
+    init_issues();
+    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
+      }
+    ];
+  }
+});
+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 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;
+}
+var init_checker = __esm({
+  "src/core/check/checker.ts"() {
+    init_issues();
+    init_rules_linter();
+  }
+});
+
+// src/core/index.ts
+var init_core = __esm({
+  "src/core/index.ts"() {
+    init_url();
+    init_sort();
+    init_text();
+    init_canonical_from_manifest();
+    init_locale();
+    init_llms_txt();
+    init_llms_full_txt();
+    init_citations();
+    init_checker();
+    init_issues();
+    init_rules_linter();
+  }
+});
+
+// src/cli/commands/generate.ts
+var generate_exports = {};
+__export(generate_exports, {
+  generateCommand: () => generateCommand
+});
+async function generateCommand(options) {
+  const { config: configPath, dryRun, emitCitations, verbose } = options;
+  try {
+    if (verbose) {
+      printVerbose(`Loading config from: ${configPath}`);
+    }
+    let loadResult;
+    try {
+      loadResult = await loadConfig({ path: configPath });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      printError(`Failed to load config: ${message}`);
+      return ExitCodes.CONFIG_NOT_FOUND;
+    }
+    const { config } = loadResult;
+    for (const issue of loadResult.issues) {
+      if (issue.severity === "warning") {
+        printWarning(issue.message);
+      } else {
+        printError(issue.message);
+        return ExitCodes.INVALID_CONFIG;
+      }
+    }
+    if (verbose) {
+      printVerbose(`Config loaded successfully`);
+      printVerbose(`Site: ${config.site.baseUrl}`);
+      printVerbose(`Brand: ${config.brand.name}`);
+    }
+    const manifestItems = extractManifestItems(config);
+    if (verbose) {
+      printVerbose(`Found ${manifestItems.length} manifest items`);
+    }
+    const canonicalUrls = createCanonicalUrlsFromManifest({
+      items: manifestItems,
+      baseUrl: config.site.baseUrl,
+      defaultLocale: config.site.defaultLocale ?? config.brand.locales[0] ?? "en",
+      trailingSlash: config.format?.trailingSlash ?? "never",
+      localeStrategy: "prefix"
+    });
+    if (verbose) {
+      printVerbose(`Generated ${canonicalUrls.length} canonical URLs`);
+    }
+    const llmsTxtResult = createLlmsTxt({ config, canonicalUrls });
+    const llmsFullTxtResult = createLlmsFullTxt({
+      config,
+      canonicalUrls,
+      manifestItems
+    });
+    let citationsContent = null;
+    if (emitCitations) {
+      citationsContent = createCitationsJsonString({
+        config,
+        manifestItems,
+        sectionName: "all"
+      });
+    }
+    const result = {
+      files: [],
+      warnings: []
+    };
+    if (dryRun) {
+      printDryRunHeader(config.output.paths.llmsTxt);
+      console.log(llmsTxtResult.content);
+      printSeparator();
+      printDryRunHeader(config.output.paths.llmsFullTxt);
+      console.log(llmsFullTxtResult.content);
+      printSeparator();
+      if (citationsContent) {
+        printDryRunHeader(config.output.paths.citations ?? "citations.json");
+        console.log(citationsContent);
+        printSeparator();
+      }
+      printInfo("Dry run complete - no files written");
+      result.files = [
+        { path: config.output.paths.llmsTxt, size: llmsTxtResult.byteSize },
+        { path: config.output.paths.llmsFullTxt, size: llmsFullTxtResult.byteSize }
+      ];
+      if (citationsContent) {
+        result.files.push({
+          path: config.output.paths.citations ?? "citations.json",
+          size: Buffer.byteLength(citationsContent, "utf-8")
+        });
+      }
+    } else {
+      if (verbose) {
+        printVerbose(`Writing ${config.output.paths.llmsTxt}`);
+      }
+      await writeFileAtomic(config.output.paths.llmsTxt, llmsTxtResult.content);
+      result.files.push({ path: config.output.paths.llmsTxt, size: llmsTxtResult.byteSize });
+      if (verbose) {
+        printVerbose(`Writing ${config.output.paths.llmsFullTxt}`);
+      }
+      await writeFileAtomic(config.output.paths.llmsFullTxt, llmsFullTxtResult.content);
+      result.files.push({ path: config.output.paths.llmsFullTxt, size: llmsFullTxtResult.byteSize });
+      if (citationsContent && config.output.paths.citations) {
+        if (verbose) {
+          printVerbose(`Writing ${config.output.paths.citations}`);
+        }
+        await writeFileAtomic(config.output.paths.citations, citationsContent);
+        result.files.push({
+          path: config.output.paths.citations,
+          size: Buffer.byteLength(citationsContent, "utf-8")
+        });
+      }
+      printGenerateReport(result.files, verbose);
+    }
+    for (const warning of result.warnings) {
+      printWarning(warning);
+    }
+    return ExitCodes.OK;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    printError(`Generation failed: ${message}`);
+    return ExitCodes.GENERATION_FAILED;
+  }
+}
+function extractManifestItems(config) {
+  const items = [];
+  const manifests = config.manifests;
+  for (const [_manifestName, manifestData] of Object.entries(manifests)) {
+    if (typeof manifestData === "object" && manifestData !== null) {
+      const data = manifestData;
+      if (Array.isArray(data.pages)) {
+        for (const page of data.pages) {
+          const normalized = toManifestItem(page);
+          if (normalized) {
+            items.push(normalized);
+          }
+        }
+      }
+      if (Array.isArray(data)) {
+        for (const item of data) {
+          const normalized = toManifestItem(item);
+          if (normalized) {
+            items.push(normalized);
+          }
+        }
+      }
+    }
+  }
+  return items;
+}
+function toManifestItem(value) {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const data = value;
+  const rawSlug = data.slug ?? data.path;
+  if (typeof rawSlug !== "string" || rawSlug.length === 0) {
+    return null;
+  }
+  const item = {
+    slug: rawSlug.startsWith("/") ? rawSlug : `/${rawSlug}`
+  };
+  if (typeof data.title === "string") {
+    item.title = data.title;
+  }
+  if (typeof data.description === "string") {
+    item.description = data.description;
+  }
+  if (Array.isArray(data.locales)) {
+    const locales = data.locales.filter((loc) => typeof loc === "string");
+    if (locales.length > 0) {
+      item.locales = locales;
+    }
+  }
+  if (typeof data.canonicalOverride === "string") {
+    item.canonicalOverride = data.canonicalOverride;
+  }
+  if (typeof data.publishedAt === "string") {
+    item.publishedAt = data.publishedAt;
+  }
+  if (typeof data.updatedAt === "string") {
+    item.updatedAt = data.updatedAt;
+  }
+  if (typeof data.priority === "number") {
+    item.priority = data.priority;
+  }
+  return item;
+}
+var init_generate = __esm({
+  "src/cli/commands/generate.ts"() {
+    init_load_config();
+    init_fs();
+    init_report();
+    init_exit_codes();
+    init_core();
+  }
+});
+
+// src/cli/commands/check.ts
+var check_exports = {};
+__export(check_exports, {
+  checkCommand: () => checkCommand
+});
+async function checkCommand(options) {
+  const { config: configPath, failOn, verbose } = options;
+  try {
+    if (verbose) {
+      printVerbose(`Loading config from: ${configPath}`);
+    }
+    let loadResult;
+    try {
+      loadResult = await loadConfig({ path: configPath });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      printError(`Failed to load config: ${message}`);
+      return ExitCodes.CONFIG_NOT_FOUND;
+    }
+    const { config } = loadResult;
+    for (const issue of loadResult.issues) {
+      if (issue.severity === "warning") {
+        printWarning(issue.message);
+      } else {
+        printError(issue.message);
+        return ExitCodes.INVALID_CONFIG;
+      }
+    }
+    if (verbose) {
+      printVerbose(`Config loaded successfully`);
+      printVerbose(`Site: ${config.site.baseUrl}`);
+    }
+    if (verbose) {
+      printVerbose("Running SEO checks...");
+    }
+    const checkOptions = {
+      config,
+      failOn,
+      llmsTxtPath: config.output.paths.llmsTxt,
+      llmsFullTxtPath: config.output.paths.llmsFullTxt,
+      ...config.output.paths.citations && { citationsPath: config.output.paths.citations }
+    };
+    const result = await checkGeneratedFiles(checkOptions);
+    const manifestItems = extractManifestItems2(config);
+    const canonicalUrls = createCanonicalUrlsFromManifest({
+      items: manifestItems,
+      baseUrl: config.site.baseUrl,
+      defaultLocale: config.site.defaultLocale ?? config.brand.locales[0] ?? "en",
+      trailingSlash: config.format?.trailingSlash ?? "never",
+      localeStrategy: "prefix"
+    });
+    const expectedLlms = createLlmsTxt({ config, canonicalUrls });
+    const expectedLlmsFull = createLlmsFullTxt({
+      config,
+      canonicalUrls,
+      manifestItems
+    });
+    const requiredMissing = result.issues.some((issue) => {
+      return issue.code === "file_missing" && (issue.path === config.output.paths.llmsTxt || issue.path === config.output.paths.llmsFullTxt);
+    });
+    let merged = result;
+    if (!requiredMissing) {
+      const mismatchIssues = await checkFilesAgainstExpected(
+        config.output.paths.llmsTxt,
+        expectedLlms.content,
+        config.output.paths.llmsFullTxt,
+        expectedLlmsFull.content
+      );
+      if (mismatchIssues.length > 0) {
+        const issues = [...result.issues, ...mismatchIssues];
+        const counts = countSeverities(issues);
+        const mismatchCount = mismatchIssues.filter((issue) => issue.code === "file_mismatch").length;
+        merged = {
+          ...result,
+          issues,
+          summary: {
+            ...result.summary,
+            errors: counts.error,
+            warnings: counts.warning,
+            info: counts.info,
+            filesMismatch: result.summary.filesMismatch + mismatchCount
+          }
+        };
+      }
+    }
+    printCheckReport(merged, verbose);
+    if (merged.summary.errors > 0) {
+      return ExitCodes.ERROR;
+    }
+    if (failOn === "warn" && merged.summary.warnings > 0) {
+      return ExitCodes.WARN;
+    }
+    return ExitCodes.OK;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    printError(`Check failed: ${message}`);
+    return ExitCodes.ERROR;
+  }
+}
+function extractManifestItems2(config) {
+  const items = [];
+  const manifests = config.manifests;
+  for (const [_manifestName, manifestData] of Object.entries(manifests)) {
+    if (typeof manifestData === "object" && manifestData !== null) {
+      const data = manifestData;
+      if (Array.isArray(data.pages)) {
+        for (const page of data.pages) {
+          const normalized = toManifestItem2(page);
+          if (normalized) {
+            items.push(normalized);
+          }
+        }
+      }
+      if (Array.isArray(data)) {
+        for (const item of data) {
+          const normalized = toManifestItem2(item);
+          if (normalized) {
+            items.push(normalized);
+          }
+        }
+      }
+    }
+  }
+  return items;
+}
+function toManifestItem2(value) {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+  const data = value;
+  const rawSlug = data.slug ?? data.path;
+  if (typeof rawSlug !== "string" || rawSlug.length === 0) {
+    return null;
+  }
+  const item = {
+    slug: rawSlug.startsWith("/") ? rawSlug : `/${rawSlug}`
+  };
+  if (typeof data.title === "string") {
+    item.title = data.title;
+  }
+  if (typeof data.description === "string") {
+    item.description = data.description;
+  }
+  if (Array.isArray(data.locales)) {
+    const locales = data.locales.filter((loc) => typeof loc === "string");
+    if (locales.length > 0) {
+      item.locales = locales;
+    }
+  }
+  if (typeof data.canonicalOverride === "string") {
+    item.canonicalOverride = data.canonicalOverride;
+  }
+  if (typeof data.publishedAt === "string") {
+    item.publishedAt = data.publishedAt;
+  }
+  if (typeof data.updatedAt === "string") {
+    item.updatedAt = data.updatedAt;
+  }
+  if (typeof data.priority === "number") {
+    item.priority = data.priority;
+  }
+  return item;
+}
+var init_check = __esm({
+  "src/cli/commands/check.ts"() {
+    init_load_config();
+    init_report();
+    init_exit_codes();
+    init_checker();
+    init_issues();
+    init_core();
+  }
+});
+
+// src/cli/commands/doctor.ts
+var doctor_exports = {};
+__export(doctor_exports, {
+  doctorCommand: () => doctorCommand
+});
+async function doctorCommand(options) {
+  const { site: siteUrl, config: configPath, verbose } = options;
+  console.log("Running llm-seo diagnostics...\n");
+  const checks = [];
+  let config = null;
+  checks.push(checkNodeVersion());
+  const configCheck = await checkConfigFile(configPath, verbose);
+  checks.push(configCheck.check);
+  if (configCheck.config) {
+    config = configCheck.config;
+  }
+  let baseUrl = siteUrl;
+  if (!baseUrl && config) {
+    baseUrl = config.site.baseUrl;
+  }
+  if (baseUrl) {
+    if (verbose) {
+      printVerbose(`Checking site: ${baseUrl}`);
+    }
+    checks.push(...await checkEndpoints(baseUrl, config, verbose));
+  } else {
+    checks.push({
+      name: "Site URL",
+      url: "",
+      status: "warn",
+      message: "No site URL specified. Use --site or configure in config file."
+    });
+  }
+  printDoctorReport(checks, verbose);
+  const hasErrors = checks.some((c) => c.status === "error");
+  const hasWarnings = checks.some((c) => c.status === "warn");
+  if (hasErrors) {
+    return ExitCodes.NETWORK_ERROR;
+  }
+  if (hasWarnings) {
+    return ExitCodes.WARN;
+  }
+  return ExitCodes.OK;
+}
+function checkNodeVersion(_verbose) {
+  const nodeVersion = process.version;
+  const majorVersion = parseInt(nodeVersion.slice(1).split(".")[0] ?? "0", 10);
+  if (majorVersion >= 18) {
+    return {
+      name: "Node.js version",
+      url: "",
+      status: "ok",
+      message: `${nodeVersion} (supported)`
+    };
+  }
+  return {
+    name: "Node.js version",
+    url: "",
+    status: "error",
+    message: `${nodeVersion} (requires Node.js 18+)`
+  };
+}
+async function checkConfigFile(configPath, verbose) {
+  let foundPath = configPath;
+  if (!foundPath) {
+    foundPath = findConfigFile() ?? void 0;
+  }
+  if (!foundPath) {
+    return {
+      check: {
+        name: "Config file",
+        url: "",
+        status: "warn",
+        message: "No config file found. Run from project directory or specify --config."
+      },
+      config: null
+    };
+  }
+  if (verbose) {
+    printVerbose(`Found config: ${foundPath}`);
+  }
+  try {
+    const loadResult = await loadConfig({ path: foundPath });
+    return {
+      check: {
+        name: "Config file",
+        url: foundPath,
+        status: "ok",
+        message: `Loaded from ${foundPath}`
+      },
+      config: loadResult.config
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      check: {
+        name: "Config file",
+        url: foundPath,
+        status: "error",
+        message: `Invalid config: ${message}`
+      },
+      config: null
+    };
+  }
+}
+async function checkEndpoints(baseUrl, config, verbose) {
+  const checks = [];
+  const normalizedBaseUrl = baseUrl.replace(/\/$/, "");
+  const robotsUrl = config?.machineHints?.robots ?? `${normalizedBaseUrl}/robots.txt`;
+  checks.push(await checkEndpoint("robots.txt", robotsUrl));
+  const sitemapUrl = config?.machineHints?.sitemap ?? `${normalizedBaseUrl}/sitemap.xml`;
+  checks.push(await checkEndpoint("sitemap.xml", sitemapUrl));
+  const sitemapIndexUrl = `${normalizedBaseUrl}/sitemap-index.xml`;
+  const sitemapIndexCheck = await checkEndpoint("sitemap-index.xml", sitemapIndexUrl, verbose, true);
+  if (sitemapIndexCheck.status === "error") {
+    sitemapIndexCheck.status = "skip";
+    sitemapIndexCheck.message = "Not found (optional)";
+  }
+  checks.push(sitemapIndexCheck);
+  const llmsTxtUrl = config?.machineHints?.llmsTxt ?? `${normalizedBaseUrl}/llms.txt`;
+  checks.push(await checkEndpoint("llms.txt", llmsTxtUrl));
+  const llmsFullTxtUrl = config?.machineHints?.llmsFullTxt ?? `${normalizedBaseUrl}/llms-full.txt`;
+  checks.push(await checkEndpoint("llms-full.txt", llmsFullTxtUrl));
+  return checks;
+}
+async function checkEndpoint(name, url, _verbose, optional = false) {
+  const startTime = Date.now();
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      signal: AbortSignal.timeout(1e4)
+      // 10 second timeout
+    });
+    const responseTime = Date.now() - startTime;
+    if (response.ok) {
+      return {
+        name,
+        url,
+        status: "ok",
+        message: "OK",
+        responseTime
+      };
+    }
+    if (response.status === 404) {
+      return {
+        name,
+        url,
+        status: optional ? "skip" : "error",
+        message: optional ? "Not found (optional)" : "HTTP 404 Not Found",
+        responseTime
+      };
+    }
+    return {
+      name,
+      url,
+      status: "error",
+      message: `HTTP ${response.status} ${response.statusText}`,
+      responseTime
+    };
+  } catch (error) {
+    const responseTime = Date.now() - startTime;
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("fetch failed") || message.includes("ENOTFOUND")) {
+      return {
+        name,
+        url,
+        status: "error",
+        message: "Connection failed (DNS or network error)",
+        responseTime
+      };
+    }
+    if (message.includes("timeout") || message.includes("Timeout")) {
+      return {
+        name,
+        url,
+        status: "error",
+        message: "Request timed out (10s)",
+        responseTime
+      };
+    }
+    return {
+      name,
+      url,
+      status: optional ? "skip" : "error",
+      message: optional ? "Not available" : `Failed: ${message}`,
+      responseTime
+    };
+  }
+}
+var init_doctor = __esm({
+  "src/cli/commands/doctor.ts"() {
+    init_load_config();
+    init_report();
+    init_exit_codes();
+  }
+});
+
+// src/cli/bin.ts
+init_exit_codes();
+var VERSION = "0.1.0";
+var program = new Command();
+program.name("llm-seo").description("Deterministic LLM SEO artifacts generator and validator for modern static sites").version(VERSION).option("-c, --config <path>", "Path to config file", "llm-seo.config.ts").option("-v, --verbose", "Enable verbose output", false);
+program.command("generate").description("Generate llms.txt and llms-full.txt from site configuration").option("-c, --config <path>", "Path to config file").option("--dry-run", "Output to stdout instead of writing files", false).option("--emit-citations", "Generate citations.json file", false).option("-v, --verbose", "Show detailed progress", false).action(async (options) => {
+  const { generateCommand: generateCommand2 } = await Promise.resolve().then(() => (init_generate(), generate_exports));
+  const exitCode = await generateCommand2({
+    config: options.config ?? program.opts().config,
+    dryRun: options.dryRun ?? false,
+    emitCitations: options.emitCitations ?? false,
+    verbose: options.verbose ?? program.opts().verbose ?? false
+  });
+  process.exit(exitCode);
+});
+program.command("check").description("Validate generated llms.txt files against configuration").option("-c, --config <path>", "Path to config file").option("--fail-on <level>", "Fail on warnings (warn) or only errors (error)", "error").option("-v, --verbose", "Show detailed output", false).action(async (options) => {
+  const { checkCommand: checkCommand2 } = await Promise.resolve().then(() => (init_check(), check_exports));
+  const failOn = options.failOn;
+  if (failOn !== "warn" && failOn !== "error") {
+    console.error(`Invalid --fail-on value: ${options.failOn}. Must be 'warn' or 'error'.`);
+    process.exit(ExitCodes.ERROR);
+  }
+  const exitCode = await checkCommand2({
+    config: options.config ?? program.opts().config,
+    failOn,
+    verbose: options.verbose ?? program.opts().verbose ?? false
+  });
+  process.exit(exitCode);
+});
+program.command("doctor").description("Diagnose common issues with llm-seo setup and site endpoints").option("-s, --site <url>", "Site URL to check (e.g., https://example.com)").option("-c, --config <path>", "Path to config file").option("-v, --verbose", "Show detailed output", false).action(async (options) => {
+  const { doctorCommand: doctorCommand2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
+  const exitCode = await doctorCommand2({
+    site: options.site,
+    config: options.config ?? program.opts().config,
+    verbose: options.verbose ?? program.opts().verbose ?? false
+  });
+  process.exit(exitCode);
+});
+program.command("help [command]").description("Display help for a specific command").action((commandName) => {
+  if (commandName) {
+    const command = program.commands.find((cmd) => cmd.name() === commandName);
+    if (command) {
+      command.outputHelp();
+    } else {
+      console.error(`Unknown command: ${commandName}`);
+      process.exit(ExitCodes.COMMAND_NOT_FOUND);
+    }
+  } else {
+    program.outputHelp();
+  }
+});
+program.on("command:*", () => {
+  console.error("Invalid command: %s\nSee --help for a list of available commands.", program.args.join(" "));
+  process.exit(ExitCodes.COMMAND_NOT_FOUND);
+});
+program.parse(process.argv);
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}
+//# sourceMappingURL=bin.js.map
+//# sourceMappingURL=bin.js.map