aiseo-audit 1.0.0

package/dist/cli.mjs

@@ -0,0 +1,2605 @@
+// src/cli.ts
+import { Command } from "commander";
+
+// src/modules/analyzer/constants.ts
+var DOMAIN_SIGNAL_TIMEOUT_CAP = 5e3;
+var VERSION = true ? "1.0.0" : "0.0.0";
+
+// src/modules/fetcher/constants.ts
+var MAX_RESPONSE_SIZE = 10 * 1024 * 1024;
+var DEFAULT_HEADERS = {
+  Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+  "Accept-Language": "en-US,en;q=0.9",
+  "Accept-Encoding": "gzip, deflate, br",
+  "Cache-Control": "no-cache"
+};
+
+// src/utils/http.ts
+async function httpGet(options) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeout);
+  try {
+    const response = await fetch(options.url, {
+      method: "GET",
+      headers: {
+        "User-Agent": options.userAgent,
+        ...DEFAULT_HEADERS
+      },
+      signal: controller.signal,
+      redirect: "follow"
+    });
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && parseInt(contentLength, 10) > MAX_RESPONSE_SIZE) {
+      throw new Error(
+        `Response exceeds maximum size of ${MAX_RESPONSE_SIZE} bytes`
+      );
+    }
+    const data = await response.text();
+    if (data.length > MAX_RESPONSE_SIZE) {
+      throw new Error(
+        `Response exceeds maximum size of ${MAX_RESPONSE_SIZE} bytes`
+      );
+    }
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      status: response.status,
+      data,
+      headers,
+      finalUrl: response.url
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function httpHead(options) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeout);
+  try {
+    const response = await fetch(options.url, {
+      method: "HEAD",
+      headers: {
+        "User-Agent": options.userAgent,
+        ...DEFAULT_HEADERS
+      },
+      signal: controller.signal,
+      redirect: "follow"
+    });
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      status: response.status,
+      data: "",
+      headers,
+      finalUrl: response.url
+    };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/utils/url.ts
+function normalizeUrl(input) {
+  let url = input.trim();
+  if (!/^https?:\/\//i.test(url)) {
+    url = `https://${url}`;
+  }
+  const parsed = new URL(url);
+  return parsed.toString().replace(/\/+$/, "");
+}
+function isValidUrl(input) {
+  try {
+    const url = normalizeUrl(input);
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getDomain(url) {
+  try {
+    return new URL(url).hostname;
+  } catch {
+    return url;
+  }
+}
+
+// src/modules/audits/constants.ts
+var CATEGORY_DISPLAY_NAMES = {
+  contentExtractability: "Content Extractability",
+  contentStructure: "Content Structure for Reuse",
+  answerability: "Answerability",
+  entityClarity: "Entity Clarity",
+  groundingSignals: "Grounding Signals",
+  authorityContext: "Authority Context",
+  readabilityForCompression: "Readability for Compression"
+};
+
+// src/modules/audits/support/patterns.ts
+var DEFINITION_PATTERNS = [
+  /\bis\s+defined\s+as\b/gi,
+  /\brefers?\s+to\b/gi,
+  /\bmeans?\s+that\b/gi,
+  /\bis\s+a\s+type\s+of\b/gi,
+  /\bcan\s+be\s+described\s+as\b/gi,
+  /\balso\s+known\s+as\b/gi
+];
+var CITATION_PATTERNS = [
+  /\[\d+\]/g,
+  /\([\w\s]+,?\s*\d{4}\)/g,
+  /according\s+to/gi,
+  /research\s+(?:shows|indicates|suggests)/gi,
+  /studies?\s+(?:show|indicate|suggest|found)/gi,
+  /data\s+from/gi,
+  /as\s+reported\s+by/gi
+];
+var ATTRIBUTION_PATTERNS = [
+  /according\s+to/gi,
+  /\bsaid\b/gi,
+  /\bstated\b/gi,
+  /\breported\b/gi,
+  /\bcited\s+by\b/gi
+];
+var NUMERIC_CLAIM_PATTERNS = [
+  /\d+(?:\.\d+)?\s*%/g,
+  /\d+(?:\.\d+)?\s*(?:million|billion|thousand|trillion)/gi,
+  /\$[\d,.]+/g,
+  /increased\s+by/gi,
+  /decreased\s+by/gi,
+  /grew\s+by/gi
+];
+var STEP_PATTERNS = [
+  /step\s+\d+/gi,
+  /^\s*\d+\.\s+\w/gm,
+  /\bfirst(?:ly)?,?\s/gi,
+  /\bsecond(?:ly)?,?\s/gi,
+  /\bfinally,?\s/gi,
+  /\bhow\s+to\b/gi
+];
+var SUMMARY_MARKERS = [
+  /\bin\s+summary\b/gi,
+  /\bin\s+conclusion\b/gi,
+  /\bto\s+summarize\b/gi,
+  /\bkey\s+takeaways?\b/gi,
+  /\bbottom\s+line\b/gi,
+  /\btl;?dr\b/gi
+];
+var QUESTION_PATTERNS = [
+  /what\s+is/gi,
+  /what\s+are/gi,
+  /how\s+to/gi,
+  /how\s+do/gi,
+  /why\s+is/gi,
+  /why\s+do/gi,
+  /when\s+to/gi,
+  /where\s+to/gi,
+  /which\s+is/gi,
+  /who\s+is/gi
+];
+var DIRECT_ANSWER_PATTERNS = [
+  /^The\s+\w+\s+is\b/gm,
+  /^It\s+is\b/gm,
+  /^This\s+is\b/gm,
+  /^They\s+are\b/gm,
+  /\bsimply\s+put\b/gi,
+  /\bin\s+short\b/gi
+];
+var TRANSITION_WORDS = [
+  "however",
+  "therefore",
+  "moreover",
+  "furthermore",
+  "consequently",
+  "additionally",
+  "in contrast",
+  "similarly",
+  "as a result",
+  "for example",
+  "for instance",
+  "on the other hand",
+  "nevertheless",
+  "meanwhile",
+  "likewise",
+  "in addition",
+  "specifically",
+  "in particular",
+  "notably",
+  "importantly"
+];
+var AUTHOR_SELECTORS = [
+  '[rel="author"]',
+  ".author",
+  ".byline",
+  '[itemprop="author"]',
+  ".post-author",
+  ".entry-author",
+  'meta[name="author"]'
+];
+var DATE_SELECTORS = [
+  "time[datetime]",
+  '[itemprop="datePublished"]',
+  '[itemprop="dateModified"]',
+  ".published",
+  ".post-date",
+  ".entry-date",
+  'meta[property="article:published_time"]',
+  'meta[property="article:modified_time"]'
+];
+var QUESTION_HEADING_PATTERN = /^(?:what|how|why|when|where|which|who|can|do|does|is|are|should|will)\b/i;
+var QUOTED_ATTRIBUTION_PATTERNS = [
+  /"[^"]{10,}"\s*[-\u2013\u2014]\s*[A-Z][a-z]+/g,
+  /"[^"]{10,}",?\s+said\s+[A-Z]/g,
+  /"[^"]{10,}",?\s+according\s+to\s+[A-Z]/g,
+  /according\s+to\s+[A-Z][a-z]+[^,]*,\s*"[^"]{10,}"/g,
+  /\u201c[^\u201d]{10,}\u201d\s*[-\u2013\u2014]\s*[A-Z][a-z]+/g,
+  /\u201c[^\u201d]{10,}\u201d,?\s+said\s+[A-Z]/g
+];
+var AI_CRAWLERS = [
+  "GPTBot",
+  "ChatGPT-User",
+  "ClaudeBot",
+  "PerplexityBot",
+  "Google-Extended"
+];
+var MODIFIED_DATE_SELECTORS = [
+  '[itemprop="dateModified"]',
+  'meta[property="article:modified_time"]'
+];
+var PUBLISH_DATE_SELECTORS = [
+  "time[datetime]",
+  '[itemprop="datePublished"]',
+  'meta[property="article:published_time"]'
+];
+
+// src/modules/audits/support/dom.ts
+function detectAnswerCapsules($) {
+  let total = 0;
+  let withCapsule = 0;
+  $("h2").each((_, el) => {
+    const headingText = $(el).text().trim();
+    const isQuestion = headingText.includes("?") || QUESTION_HEADING_PATTERN.test(headingText);
+    if (!isQuestion) return;
+    total++;
+    const nextP = $(el).nextAll("p").first();
+    if (!nextP.length) return;
+    const pText = nextP.text().trim();
+    const firstSentence = pText.split(/[.!?]/)[0] || "";
+    if (firstSentence.length > 0 && firstSentence.length <= 200) {
+      withCapsule++;
+    }
+  });
+  return { total, withCapsule };
+}
+function measureSectionLengths($) {
+  const headings = $("h1, h2, h3, h4, h5, h6");
+  if (headings.length === 0)
+    return { sectionCount: 0, avgWordsPerSection: 0, sections: [] };
+  const sections = [];
+  headings.each((_, el) => {
+    let words = 0;
+    let sibling = $(el).next();
+    while (sibling.length && !sibling.is("h1, h2, h3, h4, h5, h6")) {
+      const text = sibling.text().trim();
+      words += text.split(/\s+/).filter((w) => w.length > 0).length;
+      sibling = sibling.next();
+    }
+    if (words > 0) sections.push(words);
+  });
+  const avg = sections.length > 0 ? Math.round(sections.reduce((a, b) => a + b, 0) / sections.length) : 0;
+  return { sectionCount: sections.length, avgWordsPerSection: avg, sections };
+}
+function parseJsonLdObjects($) {
+  const objects = [];
+  $('script[type="application/ld+json"]').each((_, el) => {
+    try {
+      const data = JSON.parse($(el).html() || "{}");
+      if (Array.isArray(data)) objects.push(...data);
+      else objects.push(data);
+    } catch {
+    }
+  });
+  return objects;
+}
+
+// src/modules/audits/support/nlp.ts
+import compromise from "compromise";
+
+// src/utils/strings.ts
+function countWords(text) {
+  return text.split(/\s+/).filter((w) => w.length > 0).length;
+}
+function countSentences(text) {
+  return text.split(/[.!?]+/).filter((s) => s.trim().length > 5).length;
+}
+function countSyllables(word) {
+  word = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (word.length <= 3) return 1;
+  word = word.replace(/(?:[^laeiouy]es|ed|[^laeiouy]e)$/, "");
+  word = word.replace(/^y/, "");
+  const matches = word.match(/[aeiouy]{1,2}/g);
+  return matches ? Math.max(matches.length, 1) : 1;
+}
+
+// src/modules/audits/support/nlp.ts
+function extractEntities(text) {
+  const doc = compromise(text);
+  const people = [...new Set(doc.people().out("array"))].slice(
+    0,
+    10
+  );
+  const organizations = [
+    ...new Set(doc.organizations().out("array"))
+  ].slice(0, 10);
+  const places = [...new Set(doc.places().out("array"))].slice(
+    0,
+    10
+  );
+  const topics = [...new Set(doc.topics().out("array"))].slice(
+    0,
+    15
+  );
+  return { people, organizations, places, topics };
+}
+function computeFleschReadingEase(text) {
+  const words = text.split(/\s+/).filter((w) => w.length > 0);
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 5);
+  const totalSyllables = words.reduce((sum, w) => sum + countSyllables(w), 0);
+  if (words.length === 0 || sentences.length === 0) return 0;
+  const avgSentenceLength2 = words.length / sentences.length;
+  const avgSyllablesPerWord = totalSyllables / words.length;
+  return 206.835 - 1.015 * avgSentenceLength2 - 84.6 * avgSyllablesPerWord;
+}
+function countComplexWords(text) {
+  const words = text.split(/\s+/).filter((w) => w.length > 0);
+  return words.filter((w) => countSyllables(w) >= 4).length;
+}
+function countPatternMatches(text, patterns) {
+  let count = 0;
+  for (const pattern of patterns) {
+    const re = new RegExp(pattern.source, pattern.flags);
+    const matches = text.match(re);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+function countTransitionWords(text, words) {
+  const lower = text.toLowerCase();
+  return words.filter((w) => lower.includes(w)).length;
+}
+function avgSentenceLength(text) {
+  const words = text.split(/\s+/).filter((w) => w.length > 0);
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 5);
+  if (sentences.length === 0) return 0;
+  return Math.round(words.length / sentences.length);
+}
+
+// src/modules/audits/support/scoring.ts
+function thresholdScore(value, brackets) {
+  for (const [threshold, score] of brackets) {
+    if (value >= threshold) return score;
+  }
+  return 0;
+}
+function statusFromScore(score, maxScore) {
+  const pct = maxScore > 0 ? score / maxScore : 0;
+  if (pct >= 0.7) return "good";
+  if (pct >= 0.3) return "needs_improvement";
+  return "critical";
+}
+function makeFactor(name, score, maxScore, value, statusOverride) {
+  return {
+    name,
+    score: Math.round(Math.min(score, maxScore)),
+    maxScore,
+    value,
+    status: statusOverride ?? statusFromScore(score, maxScore)
+  };
+}
+function sumFactors(factors) {
+  return factors.reduce((sum, f) => sum + f.score, 0);
+}
+function maxFactors(factors) {
+  return factors.reduce((sum, f) => sum + f.maxScore, 0);
+}
+
+// src/modules/audits/categories/answerability.ts
+function auditAnswerability(page) {
+  const text = page.cleanText;
+  const $ = page.$;
+  const factors = [];
+  const defCount = countPatternMatches(text, DEFINITION_PATTERNS);
+  const defScore = thresholdScore(defCount, [
+    [6, 10],
+    [3, 7],
+    [1, 4],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Definition Patterns",
+      defScore,
+      10,
+      `${defCount} definition patterns`
+    )
+  );
+  const directCount = countPatternMatches(text, DIRECT_ANSWER_PATTERNS);
+  const directScore = thresholdScore(directCount, [
+    [5, 11],
+    [2, 8],
+    [1, 4],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Direct Answer Statements",
+      directScore,
+      11,
+      `${directCount} direct statements`
+    )
+  );
+  const capsules = detectAnswerCapsules(page.$);
+  const capsuleRatio = capsules.total > 0 ? capsules.withCapsule / capsules.total : 0;
+  const capsuleScore = capsules.total === 0 ? 0 : capsuleRatio >= 0.7 ? 13 : capsuleRatio >= 0.4 ? 9 : capsuleRatio > 0 ? 5 : 2;
+  factors.push(
+    makeFactor(
+      "Answer Capsules",
+      capsuleScore,
+      13,
+      capsules.total > 0 ? `${capsules.withCapsule}/${capsules.total} question headings have answer capsules` : "No question-framed H2s found",
+      capsules.total === 0 ? "neutral" : void 0
+    )
+  );
+  const stepCount = countPatternMatches(text, STEP_PATTERNS);
+  const hasOl = $("ol").length > 0;
+  const stepTotal = stepCount + (hasOl ? 2 : 0);
+  const stepScore = thresholdScore(stepTotal, [
+    [5, 10],
+    [2, 7],
+    [1, 3],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Step-by-Step Content",
+      stepScore,
+      10,
+      `${stepCount} step indicators${hasOl ? ", ordered lists found" : ""}`
+    )
+  );
+  const questionMatches = text.match(/[^.!?]*\?/g) || [];
+  const queryMatches = countPatternMatches(text, QUESTION_PATTERNS);
+  const qaScore = thresholdScore(questionMatches.length + queryMatches, [
+    [10, 11],
+    [5, 8],
+    [2, 5],
+    [1, 2],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Q/A Patterns",
+      qaScore,
+      11,
+      `${questionMatches.length} questions, ${queryMatches} query patterns`
+    )
+  );
+  const summaryCount = countPatternMatches(text, SUMMARY_MARKERS);
+  const summaryScore = summaryCount >= 2 ? 9 : summaryCount > 0 ? 5 : 0;
+  factors.push(
+    makeFactor(
+      "Summary/Conclusion",
+      summaryScore,
+      9,
+      summaryCount > 0 ? `${summaryCount} summary markers` : "No summary markers"
+    )
+  );
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.answerability,
+      key: "answerability",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData: {
+      answerCapsules: capsules,
+      questionsFound: questionMatches.slice(0, 5)
+    }
+  };
+}
+
+// src/modules/audits/support/entity.ts
+function resolveEntityName($) {
+  const ogSiteName = $('meta[property="og:site_name"]').attr("content")?.trim();
+  if (ogSiteName) return ogSiteName;
+  const jsonLdScripts = $('script[type="application/ld+json"]');
+  let orgName = null;
+  jsonLdScripts.each((_, el) => {
+    try {
+      const data = JSON.parse($(el).html() || "{}");
+      if (data["@type"] === "Organization" && data.name) {
+        orgName = String(data.name).trim();
+      }
+      if (data.publisher?.name) {
+        orgName = orgName || String(data.publisher.name).trim();
+      }
+    } catch {
+    }
+  });
+  return orgName || null;
+}
+function measureEntityConsistency($, pageTitle, entityName) {
+  if (!entityName) return { score: 0, surfacesFound: 0, surfacesChecked: 0 };
+  const nameLower = entityName.toLowerCase();
+  const surfacesChecked = 4;
+  let surfacesFound = 0;
+  if (pageTitle.toLowerCase().includes(nameLower)) surfacesFound++;
+  const ogTitle = $('meta[property="og:title"]').attr("content") || "";
+  if (ogTitle.toLowerCase().includes(nameLower)) surfacesFound++;
+  const footerText = $("footer").text().toLowerCase();
+  if (footerText.includes(nameLower)) surfacesFound++;
+  const copyrightText = $('[class*="copyright"], [class*="legal"]').text().toLowerCase();
+  const headerText = $("header").text().toLowerCase();
+  if (copyrightText.includes(nameLower) || headerText.includes(nameLower))
+    surfacesFound++;
+  const score = surfacesFound >= 4 ? 10 : surfacesFound >= 3 ? 7 : surfacesFound >= 2 ? 4 : surfacesFound >= 1 ? 2 : 0;
+  return { score, surfacesFound, surfacesChecked };
+}
+
+// src/modules/audits/support/freshness.ts
+function evaluateFreshness($) {
+  let modifiedDate = null;
+  let publishDate = null;
+  for (const sel of MODIFIED_DATE_SELECTORS) {
+    const el = $(sel).first();
+    if (el.length) {
+      modifiedDate = el.attr("datetime") || el.attr("content") || el.text().trim();
+      break;
+    }
+  }
+  for (const sel of PUBLISH_DATE_SELECTORS) {
+    const el = $(sel).first();
+    if (el.length) {
+      publishDate = el.attr("datetime") || el.attr("content") || el.text().trim();
+      break;
+    }
+  }
+  const mostRecent = modifiedDate || publishDate;
+  let ageInMonths = null;
+  if (mostRecent) {
+    const parsed = new Date(mostRecent);
+    if (!isNaN(parsed.getTime())) {
+      const now = /* @__PURE__ */ new Date();
+      ageInMonths = (now.getFullYear() - parsed.getFullYear()) * 12 + (now.getMonth() - parsed.getMonth());
+    }
+  }
+  return {
+    publishDate,
+    modifiedDate,
+    ageInMonths,
+    hasModifiedDate: !!modifiedDate
+  };
+}
+
+// src/modules/audits/support/schema-analysis.ts
+var SCHEMA_REQUIRED_PROPERTIES = {
+  Article: ["headline", "author", "datePublished"],
+  NewsArticle: ["headline", "author", "datePublished"],
+  BlogPosting: ["headline", "author", "datePublished"],
+  FAQPage: ["mainEntity"],
+  HowTo: ["name", "step"],
+  Organization: ["name", "url"],
+  LocalBusiness: ["name", "address"],
+  Product: ["name"],
+  WebPage: ["name"]
+};
+function evaluateSchemaCompleteness(schemas) {
+  const details = [];
+  for (const schema of schemas) {
+    const type = String(schema["@type"] || "");
+    const requiredProps = SCHEMA_REQUIRED_PROPERTIES[type];
+    if (!requiredProps) continue;
+    const present = requiredProps.filter((prop) => schema[prop] != null);
+    const missing = requiredProps.filter((prop) => schema[prop] == null);
+    details.push({ type, present, missing });
+  }
+  const avgCompleteness = details.length > 0 ? details.reduce(
+    (sum, d) => sum + d.present.length / (d.present.length + d.missing.length),
+    0
+  ) / details.length : 0;
+  return { totalTypes: details.length, avgCompleteness, details };
+}
+
+// src/modules/audits/categories/authority-context.ts
+function auditAuthorityContext(page) {
+  const $ = page.$;
+  const factors = [];
+  const rawData = {};
+  let authorFound = false;
+  let authorName = "";
+  for (const selector of AUTHOR_SELECTORS) {
+    const elem = $(selector).first();
+    if (elem.length) {
+      authorFound = true;
+      authorName = elem.text().trim() || elem.attr("content") || "Found";
+      break;
+    }
+  }
+  factors.push(
+    makeFactor(
+      "Author Attribution",
+      authorFound ? 10 : 0,
+      10,
+      authorFound ? authorName : "Not found"
+    )
+  );
+  const hasOrgSchema = page.html.includes('"@type":"Organization"') || page.html.includes('"@type": "Organization"');
+  const ogSiteName = $('meta[property="og:site_name"]').attr("content") || "";
+  const orgFound = hasOrgSchema || ogSiteName.length > 0;
+  factors.push(
+    makeFactor(
+      "Organization Identity",
+      orgFound ? 10 : 0,
+      10,
+      orgFound ? ogSiteName || "Schema found" : "Not found"
+    )
+  );
+  const aboutLink = $('a[href*="about"], a[href*="team"], a[href*="company"]').length > 0;
+  const contactLink = $('a[href*="contact"]').length > 0;
+  const contactScore = aboutLink && contactLink ? 10 : aboutLink || contactLink ? 5 : 0;
+  factors.push(
+    makeFactor(
+      "Contact/About Links",
+      contactScore,
+      10,
+      `${aboutLink ? "About" : ""}${aboutLink && contactLink ? " + " : ""}${contactLink ? "Contact" : ""}${!aboutLink && !contactLink ? "Not found" : ""}`
+    )
+  );
+  let dateFound = false;
+  let dateValue = "";
+  for (const selector of DATE_SELECTORS) {
+    const elem = $(selector).first();
+    if (elem.length) {
+      dateFound = true;
+      dateValue = elem.attr("datetime") || elem.attr("content") || elem.text().trim();
+      break;
+    }
+  }
+  factors.push(
+    makeFactor(
+      "Publication Date",
+      dateFound ? 8 : 0,
+      8,
+      dateFound ? dateValue : "Not found"
+    )
+  );
+  const freshness = evaluateFreshness(page.$);
+  let freshScore = 0;
+  if (freshness.ageInMonths !== null) {
+    if (freshness.ageInMonths <= 6) freshScore = 12;
+    else if (freshness.ageInMonths <= 12) freshScore = 9;
+    else if (freshness.ageInMonths <= 24) freshScore = 5;
+    else freshScore = 2;
+    if (freshness.hasModifiedDate && freshScore < 12)
+      freshScore = Math.min(freshScore + 2, 12);
+  }
+  factors.push(
+    makeFactor(
+      "Content Freshness",
+      freshScore,
+      12,
+      freshness.ageInMonths !== null ? `${freshness.ageInMonths} months old${freshness.hasModifiedDate ? ", modified date present" : ""}` : "No parseable date found"
+    )
+  );
+  rawData.freshness = freshness;
+  const jsonLdScripts = $('script[type="application/ld+json"]');
+  const structuredDataTypes = [];
+  jsonLdScripts.each((_, el) => {
+    try {
+      const data = JSON.parse($(el).html() || "{}");
+      if (data["@type"]) structuredDataTypes.push(data["@type"]);
+    } catch {
+    }
+  });
+  const ogTags = ["og:title", "og:description", "og:image", "og:type"];
+  const foundOgTags = ogTags.filter(
+    (tag) => $(`meta[property="${tag}"]`).length > 0
+  );
+  const canonical = $('link[rel="canonical"]').attr("href");
+  let structuredScore = 0;
+  if (structuredDataTypes.length > 0) structuredScore += 4;
+  if (foundOgTags.length >= 3) structuredScore += 4;
+  else if (foundOgTags.length > 0) structuredScore += 2;
+  if (canonical) structuredScore += 4;
+  rawData.structuredDataTypes = structuredDataTypes;
+  factors.push(
+    makeFactor(
+      "Structured Data",
+      structuredScore,
+      12,
+      `${structuredDataTypes.length > 0 ? structuredDataTypes.join(", ") : "No JSON-LD"}, ${foundOgTags.length}/4 OG tags${canonical ? ", canonical" : ""}`
+    )
+  );
+  const schemaObjects = parseJsonLdObjects(page.$);
+  const completeness = evaluateSchemaCompleteness(schemaObjects);
+  const schemaCompleteScore = completeness.totalTypes === 0 ? 0 : completeness.avgCompleteness >= 0.8 ? 10 : completeness.avgCompleteness >= 0.5 ? 7 : completeness.avgCompleteness > 0 ? 4 : 0;
+  factors.push(
+    makeFactor(
+      "Schema Completeness",
+      schemaCompleteScore,
+      10,
+      completeness.totalTypes > 0 ? `${completeness.totalTypes} schema types, ${Math.round(completeness.avgCompleteness * 100)}% complete` : "No recognized JSON-LD schemas found",
+      completeness.totalTypes === 0 ? "neutral" : void 0
+    )
+  );
+  rawData.schemaCompleteness = completeness;
+  const entityName = resolveEntityName(page.$);
+  const consistency = measureEntityConsistency(page.$, page.title, entityName);
+  factors.push(
+    makeFactor(
+      "Entity Consistency",
+      consistency.score,
+      10,
+      entityName ? `"${entityName}" found in ${consistency.surfacesFound}/${consistency.surfacesChecked} surfaces` : "No identifiable entity name",
+      !entityName ? "neutral" : void 0
+    )
+  );
+  rawData.entityConsistency = {
+    entityName: entityName || null,
+    surfacesFound: consistency.surfacesFound,
+    surfacesChecked: consistency.surfacesChecked
+  };
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.authorityContext,
+      key: "authorityContext",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData
+  };
+}
+
+// src/modules/audits/support/robots.ts
+function checkCrawlerAccess(robotsTxt) {
+  if (!robotsTxt)
+    return { allowed: [], blocked: [], unknown: [...AI_CRAWLERS] };
+  const lines = robotsTxt.split("\n").map((l) => l.trim());
+  const allowed = [];
+  const blocked = [];
+  const unknown = [];
+  for (const crawler of AI_CRAWLERS) {
+    const crawlerLower = crawler.toLowerCase();
+    let currentAgent = "";
+    let isBlocked = false;
+    let found = false;
+    for (const line of lines) {
+      const lower = line.toLowerCase();
+      if (lower.startsWith("user-agent:")) {
+        currentAgent = lower.split(":")[1]?.trim() || "";
+      } else if (currentAgent === crawlerLower || currentAgent === "*") {
+        if (lower.startsWith("disallow:")) {
+          const path = lower.split(":")[1]?.trim();
+          if (path === "/") {
+            if (currentAgent === crawlerLower) {
+              isBlocked = true;
+              found = true;
+            } else if (currentAgent === "*" && !found) {
+              isBlocked = true;
+            }
+          }
+        } else if (lower.startsWith("allow:")) {
+          if (currentAgent === crawlerLower) {
+            found = true;
+            isBlocked = false;
+          }
+        }
+      }
+    }
+    if (found) {
+      if (isBlocked) blocked.push(crawler);
+      else allowed.push(crawler);
+    } else if (isBlocked) {
+      blocked.push(crawler);
+    } else {
+      unknown.push(crawler);
+    }
+  }
+  return { allowed, blocked, unknown };
+}
+
+// src/modules/audits/categories/content-extractability.ts
+function auditContentExtractability(page, fetchResult, domainSignals) {
+  const factors = [];
+  const rawData = {};
+  const fetchScore = fetchResult.statusCode === 200 ? 12 : fetchResult.statusCode < 400 ? 8 : 0;
+  factors.push(
+    makeFactor(
+      "Fetch Success",
+      fetchScore,
+      12,
+      `HTTP ${fetchResult.statusCode} in ${fetchResult.fetchTimeMs}ms`
+    )
+  );
+  const extractRatio = page.stats.rawByteLength > 0 ? page.stats.cleanTextLength / page.stats.rawByteLength : 0;
+  const extractScore = extractRatio >= 0.05 && extractRatio <= 0.15 ? 12 : extractRatio >= 0.01 ? 8 : extractRatio > 0.15 ? 10 : 2;
+  factors.push(
+    makeFactor(
+      "Text Extraction Quality",
+      extractScore,
+      12,
+      `${(extractRatio * 100).toFixed(1)}% content ratio`
+    )
+  );
+  const bpRatio = page.stats.boilerplateRatio;
+  const bpScore = thresholdScore(1 - bpRatio, [
+    [0.7, 12],
+    [0.5, 9],
+    [0.3, 6],
+    [0, 2]
+  ]);
+  factors.push(
+    makeFactor(
+      "Boilerplate Ratio",
+      bpScore,
+      12,
+      `${(bpRatio * 100).toFixed(0)}% boilerplate`
+    )
+  );
+  const wc = page.stats.wordCount;
+  const wcScore = wc >= 300 && wc <= 3e3 ? 12 : wc >= 100 ? 8 : wc > 3e3 ? 10 : 2;
+  factors.push(makeFactor("Word Count Adequacy", wcScore, 12, `${wc} words`));
+  if (domainSignals) {
+    const access2 = checkCrawlerAccess(domainSignals.robotsTxt);
+    const blockedCount = access2.blocked.length;
+    const crawlerScore = blockedCount === 0 ? 10 : blockedCount <= 2 ? 6 : blockedCount <= 4 ? 3 : 0;
+    factors.push(
+      makeFactor(
+        "AI Crawler Access",
+        crawlerScore,
+        10,
+        blockedCount === 0 ? `All major AI crawlers allowed` : `${access2.blocked.join(", ")} blocked in robots.txt`
+      )
+    );
+    rawData.crawlerAccess = access2;
+    const hasLlms = domainSignals.llmsTxtExists;
+    const hasLlmsFull = domainSignals.llmsFullTxtExists;
+    const llmsScore = hasLlms && hasLlmsFull ? 6 : hasLlms || hasLlmsFull ? 4 : 0;
+    factors.push(
+      makeFactor(
+        "LLMs.txt Presence",
+        llmsScore,
+        6,
+        hasLlms && hasLlmsFull ? "llms.txt + llms-full.txt found" : hasLlms ? "llms.txt found" : hasLlmsFull ? "llms-full.txt found" : "Not found",
+        !hasLlms && !hasLlmsFull ? "neutral" : void 0
+      )
+    );
+  }
+  const imageCount = page.stats.imageCount;
+  const imagesWithAlt = page.stats.imagesWithAlt;
+  const figcaptionCount = page.$("figure figcaption").length;
+  const altRatio = imageCount > 0 ? imagesWithAlt / imageCount : 0;
+  let imageAccessibilityScore = 0;
+  if (imageCount > 0) {
+    if (altRatio >= 0.9) imageAccessibilityScore += 5;
+    else if (altRatio >= 0.5) imageAccessibilityScore += 3;
+    else imageAccessibilityScore += 1;
+    if (figcaptionCount > 0) imageAccessibilityScore += 3;
+  }
+  factors.push(
+    makeFactor(
+      "Image Accessibility",
+      imageAccessibilityScore,
+      8,
+      imageCount > 0 ? `${imagesWithAlt}/${imageCount} images have alt text${figcaptionCount > 0 ? `, ${figcaptionCount} figcaptions` : ""}` : "No images found",
+      imageCount === 0 ? "neutral" : void 0
+    )
+  );
+  rawData.imageAccessibility = { imageCount, imagesWithAlt, figcaptionCount };
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.contentExtractability,
+      key: "contentExtractability",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData
+  };
+}
+
+// src/modules/audits/categories/content-structure.ts
+function auditContentStructure(page) {
+  const $ = page.$;
+  const factors = [];
+  const h1 = page.stats.h1Count;
+  const h2 = page.stats.h2Count;
+  const h3 = page.stats.h3Count;
+  let headingScore = 0;
+  if (h1 === 1) headingScore += 4;
+  else if (h1 > 0) headingScore += 2;
+  if (h2 >= 2) headingScore += 4;
+  else if (h2 > 0) headingScore += 2;
+  if (h3 > 0) headingScore += 3;
+  factors.push(
+    makeFactor(
+      "Heading Hierarchy",
+      headingScore,
+      11,
+      `${h1} H1, ${h2} H2, ${h3} H3`
+    )
+  );
+  const listItems = page.stats.listItemCount;
+  const listScore = thresholdScore(listItems, [
+    [10, 11],
+    [5, 8],
+    [1, 4],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor("Lists Presence", listScore, 11, `${listItems} list items`)
+  );
+  const tables = page.stats.tableCount;
+  const tableScore = tables >= 2 ? 8 : tables >= 1 ? 5 : 0;
+  factors.push(
+    makeFactor(
+      "Tables Presence",
+      tableScore,
+      8,
+      `${tables} table(s)`,
+      tables === 0 ? "neutral" : void 0
+    )
+  );
+  const pCount = page.stats.paragraphCount;
+  const avgParagraphWords = pCount > 0 ? Math.round(page.stats.wordCount / pCount) : 0;
+  const paragraphScore = avgParagraphWords >= 30 && avgParagraphWords <= 150 ? 11 : avgParagraphWords > 0 && avgParagraphWords < 200 ? 7 : 2;
+  factors.push(
+    makeFactor(
+      "Paragraph Structure",
+      paragraphScore,
+      11,
+      `${pCount} paragraphs, avg ${avgParagraphWords} words`
+    )
+  );
+  const hasBold = $("strong, b").length > 0;
+  const headingRatio = pCount > 0 ? page.stats.headingCount / pCount : 0;
+  let scanScore = 0;
+  if (hasBold) scanScore += 4;
+  if (avgParagraphWords <= 150) scanScore += 4;
+  if (headingRatio >= 0.1) scanScore += 3;
+  factors.push(
+    makeFactor(
+      "Scannability",
+      scanScore,
+      11,
+      `${hasBold ? "Bold text found" : "No bold text"}, ${headingRatio.toFixed(2)} heading ratio`
+    )
+  );
+  const sectionData = measureSectionLengths(page.$);
+  let sectionScore = 0;
+  if (sectionData.sectionCount === 0) {
+    sectionScore = 0;
+  } else if (sectionData.avgWordsPerSection >= 120 && sectionData.avgWordsPerSection <= 180) {
+    sectionScore = 12;
+  } else if (sectionData.avgWordsPerSection >= 80 && sectionData.avgWordsPerSection <= 250) {
+    sectionScore = 8;
+  } else if (sectionData.avgWordsPerSection > 0) {
+    sectionScore = 4;
+  }
+  factors.push(
+    makeFactor(
+      "Section Length",
+      sectionScore,
+      12,
+      sectionData.sectionCount > 0 ? `${sectionData.sectionCount} sections, avg ${sectionData.avgWordsPerSection} words` : "No headed sections found",
+      sectionData.sectionCount === 0 ? "neutral" : void 0
+    )
+  );
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.contentStructure,
+      key: "contentStructure",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData: {
+      sectionLengths: sectionData
+    }
+  };
+}
+
+// src/modules/audits/categories/entity-clarity.ts
+function auditEntityClarity(page) {
+  const text = page.cleanText;
+  const factors = [];
+  const entities = extractEntities(text);
+  const totalEntities = entities.people.length + entities.organizations.length + entities.places.length + entities.topics.length;
+  const richScore = thresholdScore(totalEntities, [
+    [9, 20],
+    [4, 14],
+    [1, 7],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Entity Richness",
+      richScore,
+      20,
+      `${totalEntities} entities (${entities.people.length} people, ${entities.organizations.length} orgs, ${entities.places.length} places)`,
+      totalEntities === 0 ? "neutral" : void 0
+    )
+  );
+  const titleWords = page.title.toLowerCase().split(/\s+/).filter((w) => w.length > 3);
+  const h1Text = page.$("h1").first().text().toLowerCase();
+  const h1Words = h1Text.split(/\s+/).filter((w) => w.length > 3);
+  const keyWords = [.../* @__PURE__ */ new Set([...titleWords, ...h1Words])];
+  const topicLower = entities.topics.map((t) => t.toLowerCase());
+  let topicOverlap = 0;
+  for (const kw of keyWords) {
+    if (topicLower.some((t) => t.includes(kw)) || text.toLowerCase().split(kw).length > 3) {
+      topicOverlap++;
+    }
+  }
+  const consistencyRatio = keyWords.length > 0 ? topicOverlap / keyWords.length : 0;
+  const consistencyScore = consistencyRatio >= 0.5 ? 25 : consistencyRatio > 0 ? 15 : 5;
+  factors.push(
+    makeFactor(
+      "Topic Consistency",
+      consistencyScore,
+      25,
+      `${topicOverlap}/${keyWords.length} title keywords align with content topics`
+    )
+  );
+  const wordCount = countWords(text);
+  const densityPer100 = wordCount > 0 ? totalEntities / wordCount * 100 : 0;
+  const densityScore = densityPer100 >= 2 && densityPer100 <= 8 ? 15 : densityPer100 >= 1 ? 10 : densityPer100 > 8 ? 10 : 3;
+  factors.push(
+    makeFactor(
+      "Entity Density",
+      densityScore,
+      15,
+      `${densityPer100.toFixed(1)} entities per 100 words`
+    )
+  );
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.entityClarity,
+      key: "entityClarity",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData: {
+      entities
+    }
+  };
+}
+
+// src/modules/audits/categories/grounding-signals.ts
+function auditGroundingSignals(page) {
+  const $ = page.$;
+  const text = page.cleanText;
+  const factors = [];
+  const externalLinks = page.externalLinks;
+  const extScore = thresholdScore(externalLinks.length, [
+    [6, 13],
+    [3, 10],
+    [1, 6],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "External References",
+      extScore,
+      13,
+      `${externalLinks.length} external links`
+    )
+  );
+  const citationCount = countPatternMatches(text, CITATION_PATTERNS);
+  const blockquotes = $("blockquote, cite, q").length;
+  const totalCitations = citationCount + blockquotes;
+  const citScore = thresholdScore(totalCitations, [
+    [6, 13],
+    [3, 9],
+    [1, 5],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Citation Patterns",
+      citScore,
+      13,
+      `${citationCount} citation indicators, ${blockquotes} quote elements`
+    )
+  );
+  const numericCount = countPatternMatches(text, NUMERIC_CLAIM_PATTERNS);
+  const numScore = thresholdScore(numericCount, [
+    [9, 13],
+    [4, 9],
+    [1, 5],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Numeric Claims",
+      numScore,
+      13,
+      `${numericCount} statistical references`
+    )
+  );
+  const attrCount = countPatternMatches(text, ATTRIBUTION_PATTERNS);
+  const attrScore = thresholdScore(attrCount, [
+    [5, 11],
+    [2, 8],
+    [1, 4],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Attribution Indicators",
+      attrScore,
+      11,
+      `${attrCount} attribution patterns`
+    )
+  );
+  const quotedAttrPatterns = countPatternMatches(
+    text,
+    QUOTED_ATTRIBUTION_PATTERNS
+  );
+  const blockquotesWithCite = $("blockquote").filter(
+    (_, el) => $(el).find("cite, footer, figcaption").length > 0
+  ).length;
+  const totalQuotedAttr = quotedAttrPatterns + blockquotesWithCite;
+  const quotedAttrScore = thresholdScore(totalQuotedAttr, [
+    [4, 10],
+    [2, 7],
+    [1, 4],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Quoted Attribution",
+      quotedAttrScore,
+      10,
+      `${totalQuotedAttr} attributed quotes`,
+      totalQuotedAttr === 0 ? "neutral" : void 0
+    )
+  );
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.groundingSignals,
+      key: "groundingSignals",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData: {
+      externalLinks: externalLinks.slice(0, 10)
+    }
+  };
+}
+
+// src/modules/audits/categories/readability.ts
+function auditReadabilityForCompression(page) {
+  const text = page.cleanText;
+  const factors = [];
+  const avgSentLen = avgSentenceLength(text);
+  const sentScore = avgSentLen >= 12 && avgSentLen <= 22 ? 15 : avgSentLen >= 8 && avgSentLen < 30 ? 10 : avgSentLen > 0 ? 5 : 0;
+  factors.push(
+    makeFactor(
+      "Sentence Length",
+      sentScore,
+      15,
+      `Avg ${avgSentLen} words/sentence`
+    )
+  );
+  const fre = computeFleschReadingEase(text);
+  const freScore = fre >= 60 && fre <= 70 ? 15 : fre > 70 ? 13 : fre >= 50 ? 10 : fre >= 30 ? 6 : 3;
+  factors.push(
+    makeFactor(
+      "Readability",
+      freScore,
+      15,
+      `Flesch Reading Ease: ${fre.toFixed(1)}`
+    )
+  );
+  const totalWords = countWords(text);
+  const complex = countComplexWords(text);
+  const jargonRatio = totalWords > 0 ? complex / totalWords : 0;
+  const jargonScore = jargonRatio <= 0.02 ? 15 : jargonRatio <= 0.05 ? 12 : jargonRatio <= 0.1 ? 8 : 3;
+  factors.push(
+    makeFactor(
+      "Jargon Density",
+      jargonScore,
+      15,
+      `${(jargonRatio * 100).toFixed(1)}% complex words`
+    )
+  );
+  const transCount = countTransitionWords(text, TRANSITION_WORDS);
+  const transScore = thresholdScore(transCount, [
+    [10, 15],
+    [5, 11],
+    [2, 7],
+    [1, 3],
+    [0, 0]
+  ]);
+  factors.push(
+    makeFactor(
+      "Transition Usage",
+      transScore,
+      15,
+      `${transCount} transition types found`
+    )
+  );
+  return {
+    category: {
+      name: CATEGORY_DISPLAY_NAMES.readabilityForCompression,
+      key: "readabilityForCompression",
+      score: sumFactors(factors),
+      maxScore: maxFactors(factors),
+      factors
+    },
+    rawData: {
+      avgSentenceLength: avgSentLen,
+      readabilityScore: fre
+    }
+  };
+}
+
+// src/modules/audits/service.ts
+function runAudits(page, fetchResult, domainSignals) {
+  const extractability = auditContentExtractability(
+    page,
+    fetchResult,
+    domainSignals
+  );
+  const structure = auditContentStructure(page);
+  const answerability = auditAnswerability(page);
+  const entityClarity = auditEntityClarity(page);
+  const groundingSignals = auditGroundingSignals(page);
+  const authorityContext = auditAuthorityContext(page);
+  const readability = auditReadabilityForCompression(page);
+  return {
+    categories: {
+      contentExtractability: extractability.category,
+      contentStructure: structure.category,
+      answerability: answerability.category,
+      entityClarity: entityClarity.category,
+      groundingSignals: groundingSignals.category,
+      authorityContext: authorityContext.category,
+      readabilityForCompression: readability.category
+    },
+    rawData: {
+      title: page.title,
+      metaDescription: page.metaDescription,
+      wordCount: page.stats.wordCount,
+      ...extractability.rawData,
+      ...structure.rawData,
+      ...answerability.rawData,
+      ...entityClarity.rawData,
+      ...groundingSignals.rawData,
+      ...authorityContext.rawData,
+      ...readability.rawData
+    }
+  };
+}
+
+// src/modules/extractor/service.ts
+import * as cheerio from "cheerio";
+
+// src/modules/extractor/support/boilerplate.ts
+var REMOVE_SELECTORS = [
+  "script",
+  "style",
+  "noscript",
+  "svg",
+  "iframe",
+  "nav",
+  "header",
+  "footer",
+  "aside",
+  '[role="navigation"]',
+  '[role="banner"]',
+  '[role="contentinfo"]',
+  ".sidebar",
+  "#sidebar",
+  ".cookie-banner",
+  "#cookie-consent",
+  ".cookie-notice",
+  ".nav",
+  ".navbar",
+  ".footer",
+  ".header",
+  ".menu",
+  ".ad",
+  ".ads",
+  ".advertisement",
+  '[class*="cookie"]',
+  '[class*="consent"]',
+  '[class*="popup"]',
+  '[class*="modal"]'
+];
+function removeBoilerplate($) {
+  for (const selector of REMOVE_SELECTORS) {
+    $(selector).remove();
+  }
+}
+
+// src/modules/extractor/support/text.ts
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function extractCleanText($) {
+  return normalizeWhitespace($("body").text());
+}
+
+// src/modules/extractor/service.ts
+function extractPage(html, url) {
+  const $ = cheerio.load(html);
+  const title = $("title").text().trim() || $('meta[property="og:title"]').attr("content")?.trim() || "";
+  const metaDescription = $('meta[name="description"]').attr("content")?.trim() || $('meta[property="og:description"]').attr("content")?.trim() || "";
+  const rawText = $("body").text().replace(/\s+/g, " ").trim();
+  const rawByteLength = Buffer.byteLength(html, "utf-8");
+  const h1Count = $("h1").length;
+  const h2Count = $("h2").length;
+  const h3Count = $("h3").length;
+  const headingCount = h1Count + h2Count + h3Count + $("h4, h5, h6").length;
+  const linkCount = $("a[href]").length;
+  const imageCount = $("img").length;
+  const listCount = $("ul, ol").length;
+  const listItemCount = $("li").length;
+  const tableCount = $("table").length;
+  const paragraphCount = $("p").length;
+  let imagesWithAlt = 0;
+  $("img").each((_, el) => {
+    if ($(el).attr("alt")) imagesWithAlt++;
+  });
+  const pageDomain = getDomain(url);
+  const externalLinks = [];
+  $('a[href^="http"]').each((_, el) => {
+    const href = $(el).attr("href");
+    if (href) {
+      try {
+        if (getDomain(href) !== pageDomain) {
+          externalLinks.push({
+            url: href,
+            text: $(el).text().trim().substring(0, 50)
+          });
+        }
+      } catch {
+      }
+    }
+  });
+  const externalLinkCount = externalLinks.length;
+  const $clean = cheerio.load(html);
+  removeBoilerplate($clean);
+  const cleanText = extractCleanText($clean);
+  const cleanTextLength = cleanText.length;
+  const boilerplateRatio = rawText.length > 0 ? Math.max(0, Math.min(1, 1 - cleanTextLength / rawText.length)) : 0;
+  const stats = {
+    wordCount: countWords(cleanText),
+    sentenceCount: countSentences(cleanText),
+    paragraphCount,
+    headingCount,
+    h1Count,
+    h2Count,
+    h3Count,
+    linkCount,
+    externalLinkCount,
+    imageCount,
+    imagesWithAlt,
+    listCount,
+    listItemCount,
+    tableCount,
+    boilerplateRatio,
+    rawByteLength,
+    cleanTextLength
+  };
+  return {
+    url,
+    html,
+    cleanText,
+    title,
+    metaDescription,
+    stats,
+    $,
+    externalLinks
+  };
+}
+
+// src/modules/fetcher/schema.ts
+import { z } from "zod";
+var FetchOptionsSchema = z.object({
+  url: z.url(),
+  timeout: z.number().positive().default(45e3),
+  userAgent: z.string().default(`AISEOAudit/${VERSION}`)
+});
+var FetchResultSchema = z.object({
+  url: z.string(),
+  finalUrl: z.string(),
+  statusCode: z.number(),
+  contentType: z.string(),
+  html: z.string(),
+  byteLength: z.number(),
+  fetchTimeMs: z.number(),
+  redirected: z.boolean()
+});
+
+// src/modules/fetcher/service.ts
+async function fetchUrl(options) {
+  const opts = FetchOptionsSchema.parse(options);
+  const start = Date.now();
+  const response = await httpGet({
+    url: opts.url,
+    timeout: opts.timeout,
+    userAgent: opts.userAgent
+  });
+  const fetchTimeMs = Date.now() - start;
+  const html = response.data;
+  const finalUrl = response.finalUrl || opts.url;
+  const contentType = response.headers["content-type"] || "unknown";
+  return {
+    url: opts.url,
+    finalUrl,
+    statusCode: response.status,
+    contentType,
+    html,
+    byteLength: Buffer.byteLength(html, "utf-8"),
+    fetchTimeMs,
+    redirected: finalUrl !== opts.url
+  };
+}
+
+// src/modules/recommendations/constants.ts
+function static_(text) {
+  return () => text;
+}
+var RECOMMENDATION_BUILDERS = {
+  "Fetch Success": static_(
+    "Ensure the page returns HTTP 200 without excessive redirect chains. AI engines cannot extract content from pages that fail to load."
+  ),
+  "Text Extraction Quality": static_(
+    "Improve the ratio of meaningful text content to markup. Pages with very low text density are harder for AI engines to extract useful content from."
+  ),
+  "Boilerplate Ratio": static_(
+    "Reduce boilerplate content (navigation, footers, sidebars) relative to main content. Use semantic HTML elements like <main> and <article> to help engines isolate your content."
+  ),
+  "Word Count Adequacy": (rawData) => {
+    const count = rawData.wordCount;
+    if (count < 100) {
+      return `Your page has ${count} words, which is too thin for AI engines to reference. The ideal range is 300-3000 words.`;
+    }
+    if (count < 300) {
+      return `Your page has ${count} words. AI engines prefer 300-3000 words for comprehensive coverage. Consider expanding your content.`;
+    }
+    return `Your page has ${count} words, which exceeds the ideal 300-3000 word range. Consider splitting into multiple focused pages.`;
+  },
+  "AI Crawler Access": (rawData) => {
+    const access2 = rawData.crawlerAccess;
+    if (!access2 || access2.blocked.length === 0) {
+      return "Ensure AI crawlers like GPTBot, ClaudeBot, and PerplexityBot are allowed in your robots.txt.";
+    }
+    const blocked = access2.blocked.join(", ");
+    if (access2.allowed.length > 0) {
+      const allowed = access2.allowed.join(", ");
+      return `Your robots.txt is blocking ${blocked}. ${allowed} ${access2.allowed.length === 1 ? "is" : "are"} allowed. Unblock all AI crawlers so your content can be discovered and cited.`;
+    }
+    return `Your robots.txt is blocking ${blocked}. Blocking these crawlers means your content cannot be discovered or cited by AI engines.`;
+  },
+  "LLMs.txt Presence": static_(
+    "Consider adding llms.txt and llms-full.txt files at your domain root. This emerging standard provides AI systems with a structured overview of your site, helping them understand and reference your content more effectively."
+  ),
+  "Image Accessibility": (rawData) => {
+    const images = rawData.imageAccessibility;
+    if (!images || images.imageCount === 0) {
+      return "Add descriptive alt text to all images and use <figure> with <figcaption> for semantic image context.";
+    }
+    const pct = Math.round(images.imagesWithAlt / images.imageCount * 100);
+    const missing = images.imageCount - images.imagesWithAlt;
+    let text = `${images.imagesWithAlt} of your ${images.imageCount} images have alt text (${pct}%). `;
+    if (missing > 0) {
+      text += `Add alt text to the remaining ${missing} image${missing === 1 ? "" : "s"}. `;
+    }
+    if (images.figcaptionCount === 0) {
+      text += "Consider using <figure> with <figcaption> for images that need descriptive context.";
+    }
+    return text;
+  },
+  "Heading Hierarchy": static_(
+    "Use a clear H1 > H2 > H3 heading hierarchy. Headings serve as structural anchors that AI engines use to segment and reuse content."
+  ),
+  "Lists Presence": static_(
+    "Add bulleted or numbered lists to organize information. Lists are easily extracted and reused by AI engines."
+  ),
+  "Tables Presence": static_(
+    "Consider adding data tables for comparative or structured data. Tables are highly parseable by AI engines."
+  ),
+  "Paragraph Structure": static_(
+    "Keep paragraphs between 30-150 words for optimal readability and extractability."
+  ),
+  Scannability: static_(
+    "Use bold text, short paragraphs, and frequent headings to improve scannability for both humans and AI."
+  ),
+  "Section Length": (rawData) => {
+    const sections = rawData.sectionLengths;
+    if (!sections || sections.sectionCount === 0) {
+      return "Add headings to create distinct sections. Each headed section should be a self-contained unit that an AI engine could extract and reuse.";
+    }
+    const avg = Math.round(sections.avgWordsPerSection);
+    if (avg < 120) {
+      return `Your sections average ${avg} words. The citation sweet spot is 120-180 words. Consider expanding sections with more detail rather than splitting into many short fragments.`;
+    }
+    return `Your sections average ${avg} words. The citation sweet spot is 120-180 words. Consider adding more subheadings to break up long sections into self-contained units.`;
+  },
+  "Definition Patterns": static_(
+    'Define key terms and concepts clearly (e.g., "X is defined as..." or "X refers to..."). Clear definitions are directly reusable by AI engines.'
+  ),
+  "Direct Answer Statements": static_(
+    "Start key sentences with direct statements that could serve as standalone answers."
+  ),
+  "Answer Capsules": (rawData) => {
+    const capsules = rawData.answerCapsules;
+    if (!capsules || capsules.total === 0) {
+      return 'Frame your H2 headings as questions (e.g., "What is X?") and place a concise answer (under 200 characters) in the first sentence of the following paragraph. 72% of AI-cited content uses this pattern.';
+    }
+    const missing = capsules.total - capsules.withCapsule;
+    return `${capsules.withCapsule} of your ${capsules.total} question-framed H2s have a concise answer capsule. Add a short, direct answer (under 200 characters) as the first sentence after the remaining ${missing}. 72% of AI-cited content uses this pattern.`;
+  },
+  "Step-by-Step Content": static_(
+    "Break down processes into clear, numbered steps. Step-by-step content is highly reusable by AI engines."
+  ),
+  "Q/A Patterns": (rawData) => {
+    const questions = rawData.questionsFound;
+    if (!questions || questions.length === 0) {
+      return 'Include and answer common questions your audience might have. Structure content to directly answer "what is", "how to" style queries.';
+    }
+    return `Found ${questions.length} question${questions.length === 1 ? "" : "s"} in your content. Add more question-and-answer patterns to cover the queries your audience asks AI engines.`;
+  },
+  "Summary/Conclusion": static_(
+    "Add a conclusion section with key takeaways or a summary. This helps AI engines quickly extract the main points."
+  ),
+  "Entity Richness": (rawData) => {
+    const entities = rawData.entities;
+    if (!entities) {
+      return "Reference relevant experts, organizations, and places in your field. Named entities help AI engines understand context.";
+    }
+    const total = entities.people.length + entities.organizations.length + entities.places.length + entities.topics.length;
+    const parts = [];
+    if (entities.people.length > 0)
+      parts.push(`${entities.people.length} people`);
+    if (entities.organizations.length > 0)
+      parts.push(`${entities.organizations.length} organizations`);
+    if (entities.places.length > 0)
+      parts.push(`${entities.places.length} places`);
+    if (entities.topics.length > 0)
+      parts.push(`${entities.topics.length} topics`);
+    if (total === 0) {
+      return "No named entities were detected. Reference specific people, organizations, and places to help AI engines understand what your content is about.";
+    }
+    return `Found ${total} unique entities (${parts.join(", ")}). AI engines perform best with 9+ distinct entities. Add more specific names, organizations, and places relevant to your topic.`;
+  },
+  "Topic Consistency": static_(
+    "Align your main topics with your title and headings. Topic consistency helps AI engines understand what your page is about."
+  ),
+  "Entity Density": static_(
+    "Ensure a balanced density of named entities (2-8 per 100 words). Too few makes content vague; too many makes it hard to parse."
+  ),
+  "External References": (rawData) => {
+    const links = rawData.externalLinks;
+    if (!links || links.length === 0) {
+      return "Add links to reputable external sources to ground your claims. AI engines use external references to verify and attribute information.";
+    }
+    return `Found ${links.length} external link${links.length === 1 ? "" : "s"}. AI engines prefer content with 6+ external references. Add more links to authoritative sources that support your claims.`;
+  },
+  "Citation Patterns": static_(
+    'Use formal citation patterns (e.g., [1], "according to") when referencing sources.'
+  ),
+  "Numeric Claims": static_(
+    "Include relevant statistics and data points to support your content with verifiable claims."
+  ),
+  "Attribution Indicators": static_(
+    'Attribute claims to specific sources or experts. Phrases like "according to" help AI engines trace information.'
+  ),
+  "Quoted Attribution": static_(
+    'Add expert quotes with clear attribution. Use patterns like "Quote text" - Expert Name or "Quote text," said Expert Name. Research shows quotation addition increased AI visibility by 30-40%.'
+  ),
+  "Author Attribution": static_(
+    "Add visible author information with a byline to establish who created the content."
+  ),
+  "Organization Identity": static_(
+    "Add Organization structured data or og:site_name to help engines identify the source."
+  ),
+  "Contact/About Links": static_(
+    "Link to About and Contact pages to establish credibility and enable source verification."
+  ),
+  "Publication Date": static_(
+    "Include publication and last-updated dates using proper HTML5 time elements or schema markup."
+  ),
+  "Content Freshness": (rawData) => {
+    const freshness = rawData.freshness;
+    if (!freshness || freshness.ageInMonths === null) {
+      return "Add a publication or modified date to your content. 65% of AI crawler hits target content less than 1 year old. Without a parseable date, AI engines may deprioritize your content.";
+    }
+    const months = Math.round(freshness.ageInMonths);
+    if (months > 24) {
+      return `Your content was last updated ${months} months ago. AI engines strongly prefer content less than 12 months old. Consider updating with current information and refreshing the modified date.`;
+    }
+    if (months > 12) {
+      return `Your content was last updated ${months} months ago. 65% of AI crawler hits target content less than 1 year old. Refresh your content and update the modified date.`;
+    }
+    if (!freshness.hasModifiedDate) {
+      return `Your content has a publish date but no modified date. Adding a dateModified signal shows active maintenance and gives a freshness boost with AI engines.`;
+    }
+    return "Update your content to include a recent publication or modified date. Content freshness acts as a hard gate for AI engine citations.";
+  },
+  "Structured Data": (rawData) => {
+    const types = rawData.structuredDataTypes;
+    if (!types || types.length === 0) {
+      return "Add JSON-LD structured data and Open Graph tags to provide machine-readable context. Start with the schema type that matches your page (Article, Organization, Product, FAQPage, etc.).";
+    }
+    return `Found ${types.join(", ")} schema${types.length === 1 ? "" : "s"}. Ensure you also have Open Graph tags (og:title, og:description, og:image) and a canonical URL for complete structured data coverage.`;
+  },
+  "Schema Completeness": (rawData) => {
+    const schema = rawData.schemaCompleteness;
+    if (!schema || schema.details.length === 0) {
+      return "Add JSON-LD schema with all recommended properties. Complete schemas help AI engines attribute and trust your content.";
+    }
+    const incomplete = schema.details.filter((d) => d.missing.length > 0);
+    if (incomplete.length === 0) {
+      return "Ensure your JSON-LD schema types include all recommended properties for maximum AI engine trust.";
+    }
+    const summaries = incomplete.map(
+      (d) => `${d.type} is missing ${d.missing.join(", ")}`
+    );
+    return `Your ${summaries.join("; ")}. Adding these properties helps AI engines attribute and trust your content.`;
+  },
+  "Entity Consistency": (rawData) => {
+    const ec = rawData.entityConsistency;
+    if (!ec || !ec.entityName) {
+      return "Add a consistent brand or organization name across your page title, OG tags, JSON-LD schema, and footer. Consistent entity signals help AI engines confidently attribute content to your brand.";
+    }
+    return `"${ec.entityName}" was found on ${ec.surfacesFound} of ${ec.surfacesChecked} page surfaces. Ensure it appears consistently in the page title, OG tags, schema, and footer for strong brand attribution.`;
+  },
+  "Sentence Length": (rawData) => {
+    const avg = rawData.avgSentenceLength;
+    if (avg === void 0) {
+      return "Aim for an average sentence length of 12-22 words for optimal readability and compressibility.";
+    }
+    const rounded = Math.round(avg);
+    if (rounded > 22) {
+      return `Your average sentence is ${rounded} words. The ideal range for AI compression is 12-22 words. Break long sentences into shorter, more direct statements.`;
+    }
+    if (rounded < 12) {
+      return `Your average sentence is ${rounded} words. While short sentences are readable, combining some into 12-22 word sentences provides better context for AI summarization.`;
+    }
+    return `Your average sentence length is ${rounded} words. Fine-tune toward the 12-22 word sweet spot for optimal AI compression.`;
+  },
+  Readability: (rawData) => {
+    const score = rawData.readabilityScore;
+    if (score === void 0) {
+      return "Simplify language where possible. A Flesch Reading Ease score of 60-70 is ideal for broad AI reusability.";
+    }
+    const rounded = Math.round(score);
+    if (rounded < 30) {
+      return `Your Flesch Reading Ease score is ${rounded} (very difficult). A score of 60-70 is ideal. Shorten sentences, use simpler vocabulary, and break up complex ideas.`;
+    }
+    if (rounded < 50) {
+      return `Your Flesch Reading Ease score is ${rounded} (difficult). A score of 60-70 is ideal for broad AI reusability. Simplify where possible without losing meaning.`;
+    }
+    if (rounded < 60) {
+      return `Your Flesch Reading Ease score is ${rounded} (fairly difficult). You're close to the ideal 60-70 range. Minor simplification would improve AI compressibility.`;
+    }
+    return `Your Flesch Reading Ease score is ${rounded}. A score of 60-70 is ideal for broad AI reusability.`;
+  },
+  "Jargon Density": static_(
+    "Define technical terms or replace with simpler alternatives. High jargon density reduces AI reusability."
+  ),
+  "Transition Usage": static_(
+    "Use transition words (however, therefore, additionally) to improve content flow and logical structure."
+  )
+};
+
+// src/modules/recommendations/service.ts
+function generateRecommendations(auditResult) {
+  const recommendations = [];
+  for (const category of Object.values(auditResult.categories)) {
+    for (const factor of category.factors) {
+      const pct = factor.maxScore > 0 ? factor.score / factor.maxScore : 1;
+      if (pct >= 0.7) continue;
+      const priority = pct < 0.3 ? "high" : pct < 0.5 ? "medium" : "low";
+      const builder = RECOMMENDATION_BUILDERS[factor.name];
+      const recText = builder ? builder(auditResult.rawData) : `Review and improve "${factor.name}" based on best practices for AI search readiness.`;
+      recommendations.push({
+        category: category.name,
+        factor: factor.name,
+        currentValue: factor.value,
+        priority,
+        recommendation: recText
+      });
+    }
+  }
+  const priorityOrder = { high: 0, medium: 1, low: 2 };
+  recommendations.sort((a, b) => {
+    const pd = priorityOrder[a.priority] - priorityOrder[b.priority];
+    if (pd !== 0) return pd;
+    return a.factor.localeCompare(b.factor);
+  });
+  return recommendations;
+}
+
+// src/modules/scoring/constants.ts
+var GRADE_THRESHOLDS = [
+  [95, "A+"],
+  [90, "A"],
+  [85, "A-"],
+  [80, "B+"],
+  [75, "B"],
+  [70, "B-"],
+  [65, "C+"],
+  [60, "C"],
+  [55, "C-"],
+  [45, "D"],
+  [0, "F"]
+];
+
+// src/modules/scoring/service.ts
+function computeScore(categories, weights) {
+  const weightMap = {
+    contentExtractability: weights.contentExtractability,
+    contentStructure: weights.contentStructure,
+    answerability: weights.answerability,
+    entityClarity: weights.entityClarity,
+    groundingSignals: weights.groundingSignals,
+    authorityContext: weights.authorityContext,
+    readabilityForCompression: weights.readabilityForCompression
+  };
+  const totalWeight = Object.values(weightMap).reduce((sum, w) => sum + w, 0);
+  let totalPoints = 0;
+  let maxPoints = 0;
+  let weightedScore = 0;
+  for (const [key, category] of Object.entries(categories)) {
+    totalPoints += category.score;
+    maxPoints += category.maxScore;
+    const w = weightMap[key] ?? 1;
+    const normalizedWeight = totalWeight > 0 ? w / totalWeight : 1 / 7;
+    const categoryPct = category.maxScore > 0 ? category.score / category.maxScore * 100 : 0;
+    weightedScore += categoryPct * normalizedWeight;
+  }
+  const overallScore = Math.round(weightedScore);
+  const grade = computeGrade(overallScore);
+  return { overallScore, grade, totalPoints, maxPoints };
+}
+function computeGrade(score) {
+  for (const [threshold, grade] of GRADE_THRESHOLDS) {
+    if (score >= threshold) return grade;
+  }
+  return "F";
+}
+
+// src/modules/analyzer/service.ts
+async function fetchDomainSignals(domain, timeout, userAgent) {
+  const baseUrl = `https://${domain}`;
+  const cappedTimeout = Math.min(timeout, DOMAIN_SIGNAL_TIMEOUT_CAP);
+  const [robotsRes, llmsRes, llmsFullRes] = await Promise.allSettled([
+    httpGet({
+      url: `${baseUrl}/robots.txt`,
+      timeout: cappedTimeout,
+      userAgent
+    }),
+    httpHead({
+      url: `${baseUrl}/llms.txt`,
+      timeout: cappedTimeout,
+      userAgent
+    }),
+    httpHead({
+      url: `${baseUrl}/llms-full.txt`,
+      timeout: cappedTimeout,
+      userAgent
+    })
+  ]);
+  return {
+    robotsTxt: robotsRes.status === "fulfilled" && robotsRes.value.status === 200 ? robotsRes.value.data : null,
+    llmsTxtExists: llmsRes.status === "fulfilled" && llmsRes.value.status === 200,
+    llmsFullTxtExists: llmsFullRes.status === "fulfilled" && llmsFullRes.value.status === 200
+  };
+}
+async function analyzeUrl(options, config) {
+  const startTime = Date.now();
+  const url = normalizeUrl(options.url);
+  const timeout = options.timeout ?? config.timeout;
+  const userAgent = options.userAgent ?? config.userAgent;
+  const fetchResult = await fetchUrl({ url, timeout, userAgent });
+  const domain = getDomain(fetchResult.finalUrl || url);
+  const domainSignals = await fetchDomainSignals(domain, timeout, userAgent);
+  const page = extractPage(fetchResult.html, url);
+  const auditResult = runAudits(page, fetchResult, domainSignals);
+  const scoring = computeScore(auditResult.categories, config.weights);
+  const recommendations = generateRecommendations(auditResult);
+  const analysisDurationMs = Date.now() - startTime;
+  return {
+    url,
+    analyzedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    overallScore: scoring.overallScore,
+    grade: scoring.grade,
+    totalPoints: scoring.totalPoints,
+    maxPoints: scoring.maxPoints,
+    categories: auditResult.categories,
+    recommendations,
+    rawData: auditResult.rawData,
+    meta: {
+      version: VERSION,
+      analysisDurationMs
+    }
+  };
+}
+
+// src/modules/config/service.ts
+import { readFile } from "fs/promises";
+import { dirname, join, resolve } from "path";
+
+// src/utils/fs.ts
+import { access, writeFile as fsWriteFile } from "fs/promises";
+async function fileExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeOutputFile(path, content) {
+  await fsWriteFile(path, content, "utf-8");
+}
+
+// src/modules/config/constants.ts
+var CONFIG_FILENAMES = [
+  "aiseo.config.json",
+  ".aiseo.config.json",
+  "aiseo-audit.config.json"
+];
+
+// src/modules/config/schema.ts
+import { z as z2 } from "zod";
+var DEFAULT_USER_AGENT = `AISEOAudit/${VERSION}`;
+var DEFAULT_WEIGHTS = {
+  contentExtractability: 1,
+  contentStructure: 1,
+  answerability: 1,
+  entityClarity: 1,
+  groundingSignals: 1,
+  authorityContext: 1,
+  readabilityForCompression: 1
+};
+var CategoryWeightSchema = z2.object({
+  contentExtractability: z2.number().min(0).default(1),
+  contentStructure: z2.number().min(0).default(1),
+  answerability: z2.number().min(0).default(1),
+  entityClarity: z2.number().min(0).default(1),
+  groundingSignals: z2.number().min(0).default(1),
+  authorityContext: z2.number().min(0).default(1),
+  readabilityForCompression: z2.number().min(0).default(1)
+}).default(DEFAULT_WEIGHTS);
+var AiseoConfigSchema = z2.object({
+  timeout: z2.number().positive().default(45e3),
+  userAgent: z2.string().default(DEFAULT_USER_AGENT),
+  format: z2.enum(["pretty", "json", "md", "html"]).default("pretty"),
+  failUnder: z2.number().min(0).max(100).optional(),
+  weights: CategoryWeightSchema
+}).default({
+  timeout: 45e3,
+  userAgent: DEFAULT_USER_AGENT,
+  format: "pretty",
+  weights: DEFAULT_WEIGHTS
+});
+
+// src/modules/config/service.ts
+async function findConfigFile(startDir) {
+  let dir = resolve(startDir);
+  while (true) {
+    for (const filename of CONFIG_FILENAMES) {
+      const candidate = join(dir, filename);
+      if (await fileExists(candidate)) return candidate;
+    }
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function loadConfig(configPath) {
+  if (configPath) {
+    const content = await readFile(resolve(configPath), "utf-8");
+    return AiseoConfigSchema.parse(JSON.parse(content));
+  }
+  const found = await findConfigFile(process.cwd());
+  if (found) {
+    const content = await readFile(found, "utf-8");
+    return AiseoConfigSchema.parse(JSON.parse(content));
+  }
+  return AiseoConfigSchema.parse({});
+}
+
+// src/modules/report/support/html.ts
+function scoreColorHex(pct) {
+  if (pct >= 90) return "#00cc66";
+  if (pct >= 50) return "#ffaa33";
+  return "#ff3333";
+}
+function scoreTextColorHex(pct) {
+  if (pct >= 90) return "#008800";
+  if (pct >= 50) return "#ffaa33";
+  return "#cc0000";
+}
+function scoreClass(pct) {
+  if (pct >= 90) return "pass";
+  if (pct >= 50) return "average";
+  return "fail";
+}
+function statusIcon(status) {
+  if (status === "good") return "&#10003;";
+  if (status === "neutral") return "&#8212;";
+  if (status === "needs_improvement") return "&#9650;";
+  return "&#10007;";
+}
+function statusClass(status) {
+  if (status === "good") return "good";
+  if (status === "neutral") return "neutral";
+  if (status === "needs_improvement") return "warn";
+  return "fail";
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function buildGaugeSvg(score, size = "small") {
+  const pct = Math.max(0, Math.min(100, score));
+  const arcColor = scoreColorHex(pct);
+  const textColor = scoreTextColorHex(pct);
+  const radius = 56;
+  const circumference = 2 * Math.PI * radius;
+  const offset = circumference * (1 - pct / 100);
+  const dim = size === "large" ? 120 : 64;
+  const fontSize = size === "large" ? 40 : 22;
+  const strokeWidth = size === "large" ? 8 : 7;
+  return `<svg class="gauge" viewBox="0 0 120 120" width="${dim}" height="${dim}">
+      <circle cx="60" cy="60" r="${radius}" fill="none" stroke="#e0e0e0" stroke-width="${strokeWidth}"/>
+      <circle cx="60" cy="60" r="${radius}" fill="none" stroke="${arcColor}" stroke-width="${strokeWidth}"
+        stroke-dasharray="${circumference}" stroke-dashoffset="${offset}"
+        stroke-linecap="round" transform="rotate(-90 60 60)"/>
+      <text x="60" y="${60 + fontSize * 0.35}" text-anchor="middle" font-size="${fontSize}" font-weight="700" fill="${textColor}">${score}</text>
+    </svg>`;
+}
+function buildMultiSegmentGauge(overallScore, grade, totalPoints, maxPoints, categories) {
+  const radius = 56;
+  const circumference = 2 * Math.PI * radius;
+  const strokeWidth = 10;
+  const gapDeg = 1;
+  const totalGapDeg = gapDeg * categories.length;
+  const availableDeg = 360 - totalGapDeg;
+  const textColor = scoreTextColorHex(overallScore);
+  const segments = [];
+  let currentAngle = -90;
+  for (const cat of categories) {
+    const segmentDeg = maxPoints > 0 ? cat.maxScore / maxPoints * availableDeg : 0;
+    const segmentCirc = segmentDeg / 360 * circumference;
+    const fillRatio = cat.maxScore > 0 ? cat.score / cat.maxScore : 0;
+    const filledCirc = segmentCirc * fillRatio;
+    const catPct = cat.maxScore > 0 ? Math.round(fillRatio * 100) : 0;
+    const color = scoreColorHex(catPct);
+    segments.push(
+      `<circle cx="60" cy="60" r="${radius}" fill="none" stroke="#e8e8e8" stroke-width="${strokeWidth}"
+        stroke-dasharray="${segmentCirc} ${circumference - segmentCirc}"
+        transform="rotate(${currentAngle} 60 60)"/>`
+    );
+    if (filledCirc > 0) {
+      segments.push(
+        `<circle cx="60" cy="60" r="${radius}" fill="none" stroke="${color}" stroke-width="${strokeWidth}"
+          stroke-dasharray="${filledCirc} ${circumference - filledCirc}"
+          transform="rotate(${currentAngle} 60 60)"/>`
+      );
+    }
+    currentAngle += segmentDeg + gapDeg;
+  }
+  return `<div class="overall-gauge-wrap">
+    <svg class="gauge" viewBox="0 0 120 120" width="160" height="160">
+      ${segments.join("\n      ")}
+      <text x="60" y="54" text-anchor="middle" font-size="36" font-weight="700" fill="${textColor}">${overallScore}</text>
+      <text x="60" y="70" text-anchor="middle" font-size="12" font-weight="600" fill="${textColor}">${escapeHtml(grade)}</text>
+      <text x="60" y="84" text-anchor="middle" font-size="9" fill="#999">${totalPoints}/${maxPoints} pts</text>
+    </svg>
+    <div class="score-scale">
+      <span class="scale-fail">0-49</span>
+      <span class="scale-average">50-89</span>
+      <span class="scale-pass">90-100</span>
+    </div>
+  </div>`;
+}
+function buildCategoryGauge(category) {
+  const pct = category.maxScore > 0 ? Math.round(category.score / category.maxScore * 100) : 0;
+  return `<a class="gauge-item" href="#cat-${escapeHtml(category.name.replace(/\s+/g, "-").toLowerCase())}">
+      ${buildGaugeSvg(pct, "small")}
+      <span class="gauge-label">${escapeHtml(category.name)}</span>
+    </a>`;
+}
+function buildCategorySection(category) {
+  const pct = category.maxScore > 0 ? Math.round(category.score / category.maxScore * 100) : 0;
+  const cls = scoreClass(pct);
+  const id = category.name.replace(/\s+/g, "-").toLowerCase();
+  const factorRows = category.factors.map(
+    (f) => `
+          <div class="audit-row">
+            <span class="audit-icon ${statusClass(f.status)}">${statusIcon(f.status)}</span>
+            <span class="audit-name">${escapeHtml(f.name)}</span>
+            <span class="audit-detail">${escapeHtml(f.value)}</span>
+            <span class="audit-score">${f.score}/${f.maxScore}</span>
+          </div>`
+  ).join("");
+  return `
+    <div class="category" id="cat-${id}">
+      <div class="category-header">
+        <div class="category-title ${cls}">${escapeHtml(category.name)}</div>
+        <div class="category-score ${cls}">${pct}%</div>
+      </div>
+      <div class="audits">${factorRows}</div>
+    </div>`;
+}
+function buildRecommendationRow(rec) {
+  const cls = rec.priority === "high" ? "priority-high" : rec.priority === "medium" ? "priority-med" : "priority-low";
+  const label = rec.priority === "high" ? "HIGH" : rec.priority === "medium" ? "MED" : "LOW";
+  return `
+      <div class="rec-row ${cls}">
+        <span class="rec-tag">${label}</span>
+        <span class="rec-factor">${escapeHtml(rec.factor)}</span>
+        <span class="rec-text">${escapeHtml(rec.recommendation)}</span>
+      </div>`;
+}
+function buildRecommendationsByCategory(recommendations, categories) {
+  const categoryNames = Object.values(categories).map((c) => c.name);
+  const grouped = /* @__PURE__ */ new Map();
+  for (const name of categoryNames) {
+    const recs = recommendations.filter((r) => r.category === name);
+    if (recs.length > 0) grouped.set(name, recs);
+  }
+  if (grouped.size === 0) return "";
+  let html = `<div class="recs-section">
+    <div class="recs-title">Recommendations</div>`;
+  for (const [categoryName, recs] of grouped) {
+    html += `<div class="rec-group">
+      <div class="rec-group-name">${escapeHtml(categoryName)}</div>`;
+    html += recs.map(buildRecommendationRow).join("");
+    html += `</div>`;
+  }
+  html += `</div>`;
+  return html;
+}
+function renderHtml(result) {
+  const categoryEntries = Object.entries(result.categories);
+  const categories = categoryEntries.map(([, c]) => c);
+  const categoriesWithKeys = categoryEntries.map(([key, c]) => ({
+    key,
+    name: c.name,
+    score: c.score,
+    maxScore: c.maxScore
+  }));
+  const gauges = categories.map(buildCategoryGauge).join("");
+  const sections = categories.map(buildCategorySection).join("");
+  const recsHtml = buildRecommendationsByCategory(
+    result.recommendations,
+    result.categories
+  );
+  const overallGauge = buildMultiSegmentGauge(
+    result.overallScore,
+    result.grade,
+    result.totalPoints,
+    result.maxPoints,
+    categoriesWithKeys
+  );
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>AI SEO Audit - ${escapeHtml(result.url)}</title>
+<style>
+:root {
+  --pass: #00cc66;
+  --pass-text: #008800;
+  --average: #ffaa33;
+  --average-text: #ffaa33;
+  --fail: #ff3333;
+  --fail-text: #cc0000;
+  --bg: #fff;
+  --surface: #fff;
+  --text: #212121;
+  --text-secondary: #757575;
+  --border: #e0e0e0;
+  --font: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Oxygen, Ubuntu, sans-serif;
+}
+
+* { margin: 0; padding: 0; box-sizing: border-box; }
+
+body {
+  font-family: var(--font);
+  background: var(--bg);
+  color: var(--text);
+  line-height: 1.6;
+  -webkit-font-smoothing: antialiased;
+}
+
+/* Topbar */
+.topbar {
+  display: flex;
+  align-items: center;
+  height: 40px;
+  padding: 0 16px;
+  background: var(--surface);
+  border-bottom: 1px solid var(--border);
+  font-size: 13px;
+}
+.topbar-title {
+  font-weight: 600;
+  margin-right: 12px;
+  white-space: nowrap;
+}
+.topbar-url {
+  color: var(--text-secondary);
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+/* Container */
+.report {
+  max-width: 960px;
+  margin: 0 auto;
+  padding: 0 32px;
+}
+
+/* Category gauges row */
+.gauges-row {
+  display: flex;
+  flex-wrap: wrap;
+  justify-content: center;
+  align-items: flex-start;
+  gap: 12px;
+  padding: 24px 0;
+  border-bottom: 1px solid var(--border);
+}
+.gauge-item {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  width: 110px;
+  padding: 10px 6px 8px;
+  text-decoration: none;
+  color: var(--text);
+  border-radius: 8px;
+  transition: background 0.15s;
+}
+.gauge-item:hover {
+  background: #f5f5f5;
+}
+.gauge-item .gauge { display: block; }
+.gauge-label {
+  margin-top: 8px;
+  font-size: 11px;
+  font-weight: 500;
+  text-align: center;
+  color: var(--text-secondary);
+  line-height: 1.25;
+}
+
+/* Overall score */
+.overall {
+  display: flex;
+  align-items: center;
+  flex-direction: column;
+  padding: 24px 0 20px;
+  border-bottom: 1px solid var(--border);
+}
+.overall-gauge-wrap {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+.overall-gauge-wrap .gauge { display: block; }
+
+/* Score scale legend */
+.score-scale {
+  display: flex;
+  justify-content: center;
+  gap: 16px;
+  margin-top: 12px;
+  font-size: 11px;
+  color: var(--text-secondary);
+}
+.score-scale span::before {
+  content: "";
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  margin-right: 4px;
+  vertical-align: middle;
+}
+.scale-fail::before { background: var(--fail); }
+.scale-average::before { background: var(--average); }
+.scale-pass::before { background: var(--pass); }
+
+/* Categories */
+.category {
+  padding: 24px 0 16px;
+  border-bottom: 1px solid var(--border);
+}
+.category:last-child { border-bottom: none; }
+.category-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  margin-bottom: 12px;
+}
+.category-title {
+  font-size: 18px;
+  font-weight: 600;
+}
+.category-title.pass { color: var(--pass-text); }
+.category-title.average { color: var(--average-text); }
+.category-title.fail { color: var(--fail-text); }
+.category-score {
+  font-size: 14px;
+  font-weight: 700;
+}
+.category-score.pass { color: var(--pass-text); }
+.category-score.average { color: var(--average-text); }
+.category-score.fail { color: var(--fail-text); }
+
+/* Audit rows */
+.audit-row {
+  display: flex;
+  align-items: baseline;
+  padding: 8px 0;
+  border-top: 1px solid #f0f0f0;
+  font-size: 13px;
+  gap: 8px;
+}
+.audit-icon {
+  width: 18px;
+  flex-shrink: 0;
+  text-align: center;
+  font-size: 12px;
+}
+.audit-icon.good { color: var(--pass); }
+.audit-icon.warn { color: var(--average); }
+.audit-icon.fail { color: var(--fail); }
+.audit-icon.neutral { color: var(--text-secondary); }
+.audit-name {
+  font-weight: 500;
+  min-width: 180px;
+  flex-shrink: 0;
+}
+.audit-detail {
+  flex: 1;
+  color: var(--text-secondary);
+}
+.audit-score {
+  color: var(--text-secondary);
+  white-space: nowrap;
+  text-align: right;
+  min-width: 44px;
+}
+
+/* Recommendations */
+.recs-section {
+  padding: 24px 0 16px;
+  border-top: 1px solid var(--border);
+}
+.recs-title {
+  font-size: 20px;
+  font-weight: 600;
+  margin-bottom: 20px;
+}
+.rec-group {
+  margin-bottom: 20px;
+}
+.rec-group-name {
+  font-size: 13px;
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.4px;
+  color: var(--text-secondary);
+  padding-bottom: 6px;
+  border-bottom: 1px solid var(--border);
+  margin-bottom: 2px;
+}
+.rec-row {
+  display: flex;
+  gap: 10px;
+  align-items: baseline;
+  padding: 8px 0;
+  border-bottom: 1px solid #f5f5f5;
+  font-size: 13px;
+}
+.rec-tag {
+  font-size: 9px;
+  font-weight: 700;
+  padding: 2px 5px;
+  border-radius: 3px;
+  white-space: nowrap;
+  flex-shrink: 0;
+  letter-spacing: 0.3px;
+}
+.priority-high .rec-tag { background: #fce8e6; color: var(--fail-text); }
+.priority-med .rec-tag { background: #fef7e0; color: var(--average-text); }
+.priority-low .rec-tag { background: #f1f3f4; color: var(--text-secondary); }
+.rec-factor {
+  font-weight: 600;
+  white-space: nowrap;
+  flex-shrink: 0;
+}
+.rec-text { color: var(--text-secondary); }
+
+/* Footer */
+.footer {
+  padding: 16px 0;
+  border-top: 1px solid var(--border);
+  font-size: 11px;
+  color: var(--text-secondary);
+  display: flex;
+  justify-content: space-between;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+@media (max-width: 600px) {
+  .report { padding: 0 16px; }
+  .gauges-row { gap: 4px; }
+  .gauge-item { width: 80px; padding: 8px 4px; }
+  .audit-row { flex-wrap: wrap; }
+  .audit-name { min-width: 140px; }
+  .rec-row { flex-wrap: wrap; }
+}
+</style>
+</head>
+<body>
+
+<div class="topbar">
+  <span class="topbar-title">AI SEO Audit</span>
+  <span class="topbar-url">${escapeHtml(result.url)}</span>
+</div>
+
+<div class="report">
+  <div class="gauges-row">
+    ${gauges}
+  </div>
+
+  <div class="overall">
+    ${overallGauge}
+  </div>
+
+  ${sections}
+
+  ${recsHtml}
+
+  <div class="footer">
+    <span>Generated by aiseo-audit v${escapeHtml(result.meta.version)}</span>
+    <span>${escapeHtml(result.analyzedAt)} &middot; ${result.meta.analysisDurationMs}ms</span>
+  </div>
+</div>
+
+</body>
+</html>`;
+}
+
+// src/modules/report/support/json.ts
+function renderJson(result) {
+  return JSON.stringify(result, null, 2);
+}
+
+// src/modules/report/support/markdown.ts
+function renderMarkdown(result) {
+  const lines = [];
+  lines.push(`# AI SEO Audit`);
+  lines.push("");
+  lines.push(`**URL:** ${result.url}`);
+  lines.push("");
+  lines.push("| Category | Score | Percentage |");
+  lines.push("|----------|-------|------------|");
+  for (const category of Object.values(result.categories)) {
+    const pct = category.maxScore > 0 ? Math.round(category.score / category.maxScore * 100) : 0;
+    lines.push(
+      `| ${category.name} | ${category.score}/${category.maxScore} | ${pct}% |`
+    );
+  }
+  lines.push("");
+  lines.push(
+    `## Overall: ${result.overallScore}/100 (${result.grade}) - ${result.totalPoints}/${result.maxPoints} pts`
+  );
+  lines.push("");
+  for (const category of Object.values(result.categories)) {
+    const pct = category.maxScore > 0 ? Math.round(category.score / category.maxScore * 100) : 0;
+    lines.push(`### ${category.name} (${pct}%)`);
+    lines.push("");
+    lines.push("| Factor | Score | Status | Details |");
+    lines.push("|--------|-------|--------|---------|");
+    for (const factor of category.factors) {
+      const statusIcon2 = factor.status === "good" ? "pass" : factor.status === "neutral" ? "-" : factor.status === "needs_improvement" ? "warn" : "fail";
+      lines.push(
+        `| ${factor.name} | ${factor.score}/${factor.maxScore} | ${statusIcon2} | ${factor.value} |`
+      );
+    }
+    lines.push("");
+  }
+  if (result.recommendations.length > 0) {
+    lines.push("## Recommendations");
+    lines.push("");
+    const categoryNames = Object.values(result.categories).map((c) => c.name);
+    for (const categoryName of categoryNames) {
+      const categoryRecs = result.recommendations.filter(
+        (r) => r.category === categoryName
+      );
+      if (categoryRecs.length === 0) continue;
+      lines.push(`### ${categoryName}`);
+      lines.push("");
+      for (const rec of categoryRecs) {
+        const tag = rec.priority === "high" ? "**HIGH**" : rec.priority === "medium" ? "*MED*" : "LOW";
+        lines.push(`- [${tag}] **${rec.factor}**: ${rec.recommendation}`);
+      }
+      lines.push("");
+    }
+  }
+  lines.push("---");
+  lines.push(
+    `*Generated by aiseo-audit v${result.meta.version} | ${result.analyzedAt} | ${result.meta.analysisDurationMs}ms*`
+  );
+  return lines.join("\n");
+}
+
+// src/modules/report/support/pretty.ts
+import chalk from "chalk";
+function scoreColor(score, max) {
+  const pct = max > 0 ? score / max * 100 : 0;
+  if (pct >= 70) return chalk.green;
+  if (pct >= 40) return chalk.yellow;
+  return chalk.red;
+}
+function gradeColor(grade) {
+  if (grade.startsWith("A")) return chalk.green;
+  if (grade.startsWith("B")) return chalk.yellow;
+  return chalk.red;
+}
+function pad(str, len) {
+  return str + " ".repeat(Math.max(0, len - str.length));
+}
+function dots(len) {
+  return chalk.dim(".".repeat(len));
+}
+function renderPretty(result) {
+  const lines = [];
+  const width = 60;
+  const divider = chalk.dim("=".repeat(width));
+  const thinDivider = chalk.dim("-".repeat(width));
+  lines.push("");
+  lines.push(divider);
+  lines.push(chalk.bold("  AI SEO Audit Report"));
+  lines.push(chalk.dim(`  ${result.url}`));
+  lines.push(divider);
+  lines.push("");
+  const sc = scoreColor(result.overallScore, 100);
+  const gc = gradeColor(result.grade);
+  lines.push(
+    `  Overall Score: ${sc(`${result.overallScore}/100`)}  Grade: ${gc(result.grade)}`
+  );
+  lines.push(chalk.dim(`  Points: ${result.totalPoints}/${result.maxPoints}`));
+  lines.push("");
+  lines.push(thinDivider);
+  for (const category of Object.values(result.categories)) {
+    const catColor = scoreColor(category.score, category.maxScore);
+    const catPct = category.maxScore > 0 ? Math.round(category.score / category.maxScore * 100) : 0;
+    const catName = pad(category.name, 38);
+    const catDots = dots(Math.max(2, 40 - category.name.length));
+    lines.push("");
+    lines.push(
+      `  ${chalk.bold(catName)} ${catDots} ${catColor(`${category.score}/${category.maxScore}`)} ${chalk.dim(`(${catPct}%)`)}`
+    );
+    for (const factor of category.factors) {
+      const fColor = scoreColor(factor.score, factor.maxScore);
+      const fName = pad(`  ${factor.name}`, 40);
+      const fDots = dots(Math.max(2, 42 - factor.name.length));
+      lines.push(
+        `  ${chalk.dim(fName)} ${fDots} ${fColor(`${factor.score}/${factor.maxScore}`)} ${chalk.dim(factor.value)}`
+      );
+    }
+  }
+  lines.push("");
+  lines.push(thinDivider);
+  if (result.recommendations.length > 0) {
+    lines.push("");
+    lines.push(chalk.bold("  Recommendations:"));
+    lines.push("");
+    const top = result.recommendations.slice(0, 8);
+    for (let i = 0; i < top.length; i++) {
+      const rec = top[i];
+      const tag = rec.priority === "high" ? chalk.red(`[HIGH]`) : rec.priority === "medium" ? chalk.yellow(`[MED] `) : chalk.dim(`[LOW] `);
+      lines.push(`  ${i + 1}. ${tag} ${chalk.bold(rec.factor)}`);
+      lines.push(`     ${chalk.dim(rec.recommendation)}`);
+      lines.push("");
+    }
+    if (result.recommendations.length > 8) {
+      lines.push(
+        chalk.dim(
+          `  ... and ${result.recommendations.length - 8} more recommendations. Use --out <path> and print this to a file to see the full list.`
+        )
+      );
+    }
+  }
+  lines.push(divider);
+  lines.push(chalk.dim(`  Analyzed at: ${result.analyzedAt}`));
+  lines.push(chalk.dim(`  Duration: ${result.meta.analysisDurationMs}ms`));
+  lines.push(divider);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/modules/report/service.ts
+function renderReport(result, options) {
+  switch (options.format) {
+    case "json":
+      return renderJson(result);
+    case "md":
+      return renderMarkdown(result);
+    case "html":
+      return renderHtml(result);
+    case "pretty":
+    default:
+      return renderPretty(result);
+  }
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("aiseo-audit").description("Audit web pages for AI search readiness").version(VERSION).argument("<url>", "URL to audit").option("--json", "Output as JSON").option("--md", "Output as Markdown").option("--html", "Output as HTML").option("--out <path>", "Write rendered output to a file").option(
+  "--fail-under <score>",
+  "Exit with code 1 if score is below threshold",
+  parseFloat
+).option("--timeout <ms>", "Request timeout in milliseconds", parseInt).option("--user-agent <ua>", "Custom User-Agent string").option("--config <path>", "Path to aiseo.config.json config file").action(
+  async (url, opts) => {
+    try {
+      if (!isValidUrl(url)) {
+        console.error(`Error: Invalid URL "${url}"`);
+        process.exit(2);
+      }
+      const config = await loadConfig(opts.config);
+      const format = opts.json ? "json" : opts.md ? "md" : opts.html ? "html" : config.format;
+      const timeout = opts.timeout ?? config.timeout;
+      const userAgent = opts.userAgent ?? config.userAgent;
+      const result = await analyzeUrl({ url, timeout, userAgent }, config);
+      const output = renderReport(result, { format });
+      if (opts.out) {
+        await writeOutputFile(opts.out, output);
+        console.error(`Results written to ${opts.out}`);
+      } else {
+        console.log(output);
+      }
+      const failUnder = opts.failUnder ?? config.failUnder;
+      if (failUnder !== void 0 && result.overallScore < failUnder) {
+        console.error(
+          `
+Score ${result.overallScore} is below threshold ${failUnder}`
+        );
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(
+        "Audit failed:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(2);
+    }
+  }
+);
+program.parse();
+//# sourceMappingURL=cli.mjs.map