@glincker/geo-audit 0.1.0

package/dist/cli.js

@@ -0,0 +1,1808 @@
+#!/usr/bin/env node
+import chalk from 'chalk';
+import * as cheerio from 'cheerio';
+
+// src/fetcher.ts
+var DEFAULT_TIMEOUT = 1e4;
+var DEFAULT_USER_AGENT = "GeoKit/0.1.0 (+https://geo.glincker.com; AI-readiness audit)";
+var BLOCKED_PATTERNS = [
+  /^127\./,
+  /^10\./,
+  /^172\.(1[6-9]|2\d|3[01])\./,
+  /^192\.168\./,
+  /^0\./,
+  /^localhost$/i,
+  /^\[::1\]$/
+];
+function isBlockedHost(hostname) {
+  return BLOCKED_PATTERNS.some((p) => p.test(hostname));
+}
+function normalizeUrl(input) {
+  let url = input.trim();
+  if (!/^https?:\/\//i.test(url)) {
+    url = `https://${url}`;
+  }
+  return url;
+}
+async function safeFetch(url, options) {
+  const parsed = new URL(url);
+  if (isBlockedHost(parsed.hostname)) {
+    throw new Error(`Blocked: ${parsed.hostname} is a private/internal address`);
+  }
+  const controller = new AbortController();
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  const timer = setTimeout(() => controller.abort(), timeout);
+  try {
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: {
+        "User-Agent": options.userAgent ?? DEFAULT_USER_AGENT,
+        Accept: "text/html,application/xhtml+xml,*/*"
+      },
+      redirect: "follow"
+    });
+    return res;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchResource(url, options) {
+  try {
+    const res = await safeFetch(url, options);
+    const body = await res.text();
+    return { ok: res.ok, status: res.status, body };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown fetch error";
+    return { ok: false, status: 0, body: "", error: message };
+  }
+}
+async function fetchPageData(rawUrl, options = {}) {
+  const url = normalizeUrl(rawUrl);
+  const origin = new URL(url).origin;
+  const startTime = performance.now();
+  let ttfb = 0;
+  const mainRes = await safeFetch(url, options);
+  ttfb = performance.now() - startTime;
+  const html = await mainRes.text();
+  const totalTime = performance.now() - startTime;
+  const headers = {};
+  mainRes.headers.forEach((value, key) => {
+    headers[key.toLowerCase()] = value;
+  });
+  const [llmsTxt, robotsTxt, sitemapXml] = await Promise.all([
+    fetchResource(`${origin}/llms.txt`, options),
+    fetchResource(`${origin}/robots.txt`, options),
+    fetchResource(`${origin}/sitemap.xml`, options)
+  ]);
+  return {
+    url,
+    html,
+    statusCode: mainRes.status,
+    headers,
+    ttfb,
+    totalTime,
+    llmsTxt,
+    robotsTxt,
+    sitemapXml
+  };
+}
+
+// src/rules/r01-llms-txt.ts
+var r01LlmsTxt = {
+  id: "R01",
+  name: "llms.txt Exists",
+  description: "Check for /llms.txt file that helps AI systems understand your site",
+  category: "discoverability",
+  maxScore: 10,
+  check(page) {
+    const { llmsTxt } = page;
+    if (!llmsTxt.ok || llmsTxt.status !== 200) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "No /llms.txt file found",
+        recommendation: "Add /llms.txt to help AI systems understand your site. See https://llmstxt.org for the spec."
+      };
+    }
+    const body = llmsTxt.body.trim();
+    if (body.length === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "/llms.txt exists but is empty",
+        recommendation: "Add content to your /llms.txt \u2014 it should be valid markdown with an H1 heading."
+      };
+    }
+    const hasH1 = /^#\s+.+/m.test(body);
+    if (!hasH1) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 5,
+        maxScore: this.maxScore,
+        message: "/llms.txt exists but missing H1 heading",
+        recommendation: "Add a markdown H1 heading (# Your Site Name) to your /llms.txt for proper structure."
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 10,
+      maxScore: this.maxScore,
+      message: "/llms.txt found with valid markdown structure"
+    };
+  }
+};
+
+// src/rules/r02-robots-txt.ts
+var AI_BOTS = [
+  "GPTBot",
+  "ClaudeBot",
+  "PerplexityBot",
+  "Google-Extended",
+  "Amazonbot",
+  "anthropic-ai",
+  "CCBot",
+  "ChatGPT-User",
+  "Bytespider",
+  "cohere-ai"
+];
+var r02RobotsTxt = {
+  id: "R02",
+  name: "robots.txt AI Crawler Rules",
+  description: "Check if robots.txt has explicit rules for AI crawlers",
+  category: "discoverability",
+  maxScore: 10,
+  check(page) {
+    const { robotsTxt } = page;
+    if (!robotsTxt.ok || robotsTxt.status !== 200) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "No robots.txt found",
+        recommendation: "Add a robots.txt file with explicit rules for AI crawlers (GPTBot, ClaudeBot, etc.)"
+      };
+    }
+    const body = robotsTxt.body.toLowerCase();
+    const foundBots = AI_BOTS.filter(
+      (bot) => body.includes(`user-agent: ${bot.toLowerCase()}`)
+    );
+    if (foundBots.length === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 5,
+        maxScore: this.maxScore,
+        message: "robots.txt exists but has no AI-specific crawler rules",
+        recommendation: "Add explicit User-agent rules for GPTBot, ClaudeBot, and PerplexityBot to control AI crawler access.",
+        details: { foundBots: [] }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 10,
+      maxScore: this.maxScore,
+      message: `robots.txt has rules for ${foundBots.length} AI crawler(s)`,
+      details: { foundBots }
+    };
+  }
+};
+
+// src/rules/r03-sitemap.ts
+var r03Sitemap = {
+  id: "R03",
+  name: "Sitemap.xml Exists",
+  description: "Check for XML sitemap for AI crawler discovery",
+  category: "discoverability",
+  maxScore: 10,
+  check(page) {
+    const { sitemapXml, robotsTxt } = page;
+    let sitemapInRobots = false;
+    if (robotsTxt.ok) {
+      sitemapInRobots = /^sitemap:\s*https?:\/\//im.test(robotsTxt.body);
+    }
+    const sitemapExists = sitemapXml.ok && sitemapXml.status === 200;
+    const isXml = sitemapExists && (sitemapXml.body.includes("<?xml") || sitemapXml.body.includes("<urlset") || sitemapXml.body.includes("<sitemapindex"));
+    if (isXml) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "pass",
+        score: 10,
+        maxScore: this.maxScore,
+        message: "Valid XML sitemap found",
+        details: { sitemapInRobots }
+      };
+    }
+    if (sitemapInRobots) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 5,
+        maxScore: this.maxScore,
+        message: "Sitemap referenced in robots.txt but /sitemap.xml not directly accessible",
+        recommendation: "Ensure your sitemap.xml is accessible at the root URL for maximum crawler compatibility."
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "fail",
+      score: 0,
+      maxScore: this.maxScore,
+      message: "No sitemap.xml found",
+      recommendation: "Add a sitemap.xml to help AI crawlers discover all your pages."
+    };
+  }
+};
+var KNOWN_TYPES = [
+  "Organization",
+  "WebPage",
+  "WebSite",
+  "Article",
+  "BlogPosting",
+  "FAQ",
+  "FAQPage",
+  "Product",
+  "LocalBusiness",
+  "Person",
+  "BreadcrumbList",
+  "HowTo",
+  "Event",
+  "SoftwareApplication",
+  "Course",
+  "Recipe",
+  "VideoObject"
+];
+var r04JsonLd = {
+  id: "R04",
+  name: "JSON-LD Schema.org Markup",
+  description: "Check for structured data using JSON-LD format",
+  category: "structured-data",
+  maxScore: 10,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const scripts = $('script[type="application/ld+json"]');
+    if (scripts.length === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "No JSON-LD structured data found",
+        recommendation: "Add JSON-LD Schema.org markup to help AI understand your page content. Start with Organization or WebPage schema."
+      };
+    }
+    const types = [];
+    let hasErrors = false;
+    scripts.each((_, el) => {
+      const text = $(el).text();
+      try {
+        const data = JSON.parse(text);
+        const extractType = (obj) => {
+          if (obj["@type"]) {
+            const t = Array.isArray(obj["@type"]) ? obj["@type"] : [obj["@type"]];
+            types.push(...t);
+          }
+          if (obj["@graph"] && Array.isArray(obj["@graph"])) {
+            for (const item of obj["@graph"]) {
+              extractType(item);
+            }
+          }
+        };
+        extractType(data);
+      } catch {
+        hasErrors = true;
+      }
+    });
+    if (hasErrors && types.length === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 3,
+        maxScore: this.maxScore,
+        message: "JSON-LD found but contains parse errors",
+        recommendation: "Fix JSON-LD syntax errors. Validate at https://search.google.com/test/rich-results",
+        details: { types }
+      };
+    }
+    const recognized = types.filter((t) => KNOWN_TYPES.includes(t));
+    if (types.length > 0 && recognized.length === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 5,
+        maxScore: this.maxScore,
+        message: `JSON-LD found with unrecognized type(s): ${types.join(", ")}`,
+        recommendation: "Use standard Schema.org types like Organization, WebPage, Article, or Product.",
+        details: { types }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 10,
+      maxScore: this.maxScore,
+      message: `JSON-LD found: ${recognized.join(", ")}`,
+      details: { types: recognized }
+    };
+  }
+};
+var CORE_OG_TAGS = ["og:title", "og:description", "og:image", "og:type"];
+var r05OpenGraph = {
+  id: "R05",
+  name: "OpenGraph Tags",
+  description: "Check for core OpenGraph meta tags (title, description, image, type)",
+  category: "structured-data",
+  maxScore: 10,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const found = [];
+    const missing = [];
+    for (const tag of CORE_OG_TAGS) {
+      const el = $(`meta[property="${tag}"]`);
+      if (el.length > 0 && el.attr("content")?.trim()) {
+        found.push(tag);
+      } else {
+        missing.push(tag);
+      }
+    }
+    if (found.length === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "No OpenGraph tags found",
+        recommendation: "Add og:title, og:description, og:image, and og:type meta tags for better AI and social sharing.",
+        details: { found, missing }
+      };
+    }
+    if (missing.length > 0) {
+      const score = Math.round(found.length / CORE_OG_TAGS.length * this.maxScore);
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score,
+        maxScore: this.maxScore,
+        message: `Missing OpenGraph tags: ${missing.join(", ")}`,
+        recommendation: `Add missing tags: ${missing.join(", ")}`,
+        details: { found, missing }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 10,
+      maxScore: this.maxScore,
+      message: "All 4 core OpenGraph tags present",
+      details: { found }
+    };
+  }
+};
+var r06MetaDescription = {
+  id: "R06",
+  name: "Meta Description",
+  description: "Check for meta description tag with appropriate length",
+  category: "structured-data",
+  maxScore: 5,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const el = $('meta[name="description"]');
+    const content = el.attr("content")?.trim() ?? "";
+    if (!content) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "No meta description found",
+        recommendation: "Add a meta description (50-160 characters) to summarize your page content."
+      };
+    }
+    const len = content.length;
+    if (len < 50) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 2,
+        maxScore: this.maxScore,
+        message: `Meta description too short (${len} chars, min 50)`,
+        recommendation: "Expand your meta description to at least 50 characters for better AI comprehension.",
+        details: { length: len }
+      };
+    }
+    if (len > 160) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 3,
+        maxScore: this.maxScore,
+        message: `Meta description too long (${len} chars, max 160)`,
+        recommendation: "Shorten your meta description to 160 characters or less.",
+        details: { length: len }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 5,
+      maxScore: this.maxScore,
+      message: `Meta description present (${len} chars)`,
+      details: { length: len }
+    };
+  }
+};
+var r07Canonical = {
+  id: "R07",
+  name: "Canonical URL",
+  description: "Check for link rel=canonical with absolute URL",
+  category: "structured-data",
+  maxScore: 5,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const el = $('link[rel="canonical"]');
+    const href = el.attr("href")?.trim() ?? "";
+    if (!href) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "No canonical URL found",
+        recommendation: 'Add <link rel="canonical" href="https://..."> to prevent duplicate content issues with AI crawlers.'
+      };
+    }
+    const isAbsolute = /^https?:\/\//i.test(href);
+    if (!isAbsolute) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 2,
+        maxScore: this.maxScore,
+        message: "Canonical URL is relative, should be absolute",
+        recommendation: "Use an absolute URL (starting with https://) for the canonical link.",
+        details: { canonical: href }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 5,
+      maxScore: this.maxScore,
+      message: "Canonical URL present",
+      details: { canonical: href }
+    };
+  }
+};
+var r08Headings = {
+  id: "R08",
+  name: "Heading Hierarchy",
+  description: "Check for proper heading structure (single H1, no skipped levels)",
+  category: "content-quality",
+  maxScore: 10,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const headings = [];
+    $("h1, h2, h3, h4, h5, h6").each((_, el) => {
+      const tag = $(el).prop("tagName")?.toLowerCase() ?? "";
+      const level = parseInt(tag.replace("h", ""), 10);
+      const text = $(el).text().trim();
+      if (!isNaN(level)) {
+        headings.push({ level, text });
+      }
+    });
+    if (headings.length === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "No headings found on page",
+        recommendation: "Add an H1 heading and use proper heading hierarchy for AI content parsing."
+      };
+    }
+    const h1Count = headings.filter((h) => h.level === 1).length;
+    const issues = [];
+    if (h1Count === 0) {
+      issues.push("No H1 heading found");
+    } else if (h1Count > 1) {
+      issues.push(`Multiple H1 headings (${h1Count})`);
+    }
+    for (let i = 1; i < headings.length; i++) {
+      const prev = headings[i - 1].level;
+      const curr = headings[i].level;
+      if (curr > prev + 1) {
+        issues.push(`Skipped from H${prev} to H${curr}`);
+        break;
+      }
+    }
+    if (h1Count === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 2,
+        maxScore: this.maxScore,
+        message: issues.join("; "),
+        recommendation: "Add a single H1 heading that describes your page content.",
+        details: { h1Count, totalHeadings: headings.length, issues }
+      };
+    }
+    if (issues.length > 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 5,
+        maxScore: this.maxScore,
+        message: issues.join("; "),
+        recommendation: "Fix heading hierarchy: use a single H1 and don't skip levels (e.g., H1 \u2192 H3 without H2).",
+        details: { h1Count, totalHeadings: headings.length, issues }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 10,
+      maxScore: this.maxScore,
+      message: `Proper heading hierarchy (${headings.length} headings)`,
+      details: { h1Count, totalHeadings: headings.length }
+    };
+  }
+};
+var r09SsrContent = {
+  id: "R09",
+  name: "Content Accessibility (SSR)",
+  description: "Check if meaningful content is available in initial HTML without JavaScript",
+  category: "content-quality",
+  maxScore: 10,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    $("script, style, noscript, nav, footer, header, svg, iframe").remove();
+    const bodyText = $("body").text().replace(/\s+/g, " ").trim();
+    const textLength = bodyText.length;
+    if (textLength < 100) {
+      const hasReactRoot = $('[id="root"], [id="app"], [id="__next"]').length > 0;
+      const hasJsBundles = page.html.includes(".js") && textLength < 50;
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: hasJsBundles || hasReactRoot ? "Page appears to be client-side rendered only \u2014 AI crawlers can't read JavaScript" : `Very little text content in initial HTML (${textLength} chars)`,
+        recommendation: "Use server-side rendering (SSR) or static generation (SSG) so AI crawlers can read your content without JavaScript.",
+        details: { textLength, isClientOnly: hasReactRoot || hasJsBundles }
+      };
+    }
+    if (textLength < 500) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 5,
+        maxScore: this.maxScore,
+        message: `Thin content in initial HTML (${textLength} chars)`,
+        recommendation: "Consider adding more server-rendered content. AI crawlers prefer text-heavy pages.",
+        details: { textLength }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 10,
+      maxScore: this.maxScore,
+      message: `Good server-rendered content (${textLength} chars)`,
+      details: { textLength }
+    };
+  }
+};
+var r10Faq = {
+  id: "R10",
+  name: "FAQ Content Detection",
+  description: "Check for FAQ content and corresponding FAQ schema markup",
+  category: "content-quality",
+  maxScore: 5,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const hasFaqHeading = /faq|frequently\s+asked|questions/i.test(page.html);
+    const hasDlList = $("dl dt").length >= 2;
+    const hasDetailsSummary = $("details summary").length >= 2;
+    const hasAccordion = $('[class*="accordion"], [class*="faq"], [data-faq]').length > 0;
+    const hasFaqContent = hasFaqHeading || hasDlList || hasDetailsSummary || hasAccordion;
+    if (!hasFaqContent) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "skip",
+        score: 5,
+        // Full points if no FAQ content — not penalized
+        maxScore: this.maxScore,
+        message: "No FAQ content detected (not penalized)"
+      };
+    }
+    let hasFaqSchema = false;
+    $('script[type="application/ld+json"]').each((_, el) => {
+      const text = $(el).text();
+      try {
+        const data = JSON.parse(text);
+        const checkType = (obj) => {
+          if (obj["@type"] === "FAQPage" || obj["@type"] === "FAQ") return true;
+          if (obj["@graph"] && Array.isArray(obj["@graph"])) {
+            return obj["@graph"].some(
+              (item) => checkType(item)
+            );
+          }
+          return false;
+        };
+        if (checkType(data)) hasFaqSchema = true;
+      } catch {
+      }
+    });
+    if (!hasFaqSchema) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 2,
+        maxScore: this.maxScore,
+        message: "FAQ content detected but no FAQPage schema markup",
+        recommendation: "Add FAQPage JSON-LD schema to your FAQ section \u2014 FAQ schema has the highest citation rate in AI-generated answers."
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 5,
+      maxScore: this.maxScore,
+      message: "FAQ content with FAQPage schema markup detected"
+    };
+  }
+};
+
+// src/rules/r11-response-time.ts
+var r11ResponseTime = {
+  id: "R11",
+  name: "Response Time",
+  description: "Check Time to First Byte (TTFB) \u2014 AI crawlers have strict timeouts",
+  category: "technical",
+  maxScore: 10,
+  check(page) {
+    const ttfb = Math.round(page.ttfb);
+    if (ttfb > 2e3) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: `Slow TTFB: ${ttfb}ms (should be <500ms)`,
+        recommendation: "Improve server response time. AI crawlers may skip slow sites. Consider caching, CDN, or server optimization.",
+        details: { ttfb }
+      };
+    }
+    if (ttfb > 500) {
+      const score = Math.max(2, Math.round(10 - (ttfb - 500) / 1500 * 8));
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score,
+        maxScore: this.maxScore,
+        message: `Moderate TTFB: ${ttfb}ms (target <500ms)`,
+        recommendation: "Consider improving server response time for better AI crawler compatibility.",
+        details: { ttfb }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 10,
+      maxScore: this.maxScore,
+      message: `Fast TTFB: ${ttfb}ms`,
+      details: { ttfb }
+    };
+  }
+};
+
+// src/rules/r12-content-type.ts
+var r12ContentType = {
+  id: "R12",
+  name: "Content-Type & Encoding",
+  description: "Verify proper content-type header and compression",
+  category: "technical",
+  maxScore: 5,
+  check(page) {
+    const contentType = page.headers["content-type"] ?? "";
+    const encoding = page.headers["content-encoding"] ?? "";
+    const isHtml = contentType.includes("text/html");
+    const hasCharset = contentType.includes("charset=") || contentType.includes("utf-8");
+    const hasCompression = encoding.includes("gzip") || encoding.includes("br") || encoding.includes("deflate");
+    if (!isHtml) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: `Wrong content-type: ${contentType || "(none)"}`,
+        recommendation: "Ensure your server returns Content-Type: text/html; charset=utf-8",
+        details: { contentType, encoding }
+      };
+    }
+    const issues = [];
+    let score = 5;
+    if (!hasCharset) {
+      issues.push("missing charset");
+      score -= 1;
+    }
+    if (!hasCompression) {
+      issues.push("no compression (gzip/brotli)");
+      score -= 2;
+    }
+    if (issues.length > 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score,
+        maxScore: this.maxScore,
+        message: `Content-type OK but ${issues.join(", ")}`,
+        recommendation: issues.includes("no compression") ? "Enable gzip or brotli compression to reduce payload size for AI crawlers." : "Add charset=utf-8 to your Content-Type header.",
+        details: { contentType, encoding }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 5,
+      maxScore: this.maxScore,
+      message: "Proper content-type with compression",
+      details: { contentType, encoding }
+    };
+  }
+};
+var r13LangTag = {
+  id: "R13",
+  name: "Language Tag",
+  description: "Check for lang attribute on <html> element for accessibility and i18n",
+  category: "content-quality",
+  maxScore: 3,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const htmlEl = $("html");
+    const langAttr = htmlEl.attr("lang");
+    if (!langAttr || langAttr.trim() === "") {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "No lang attribute found on <html> element",
+        recommendation: 'Add lang attribute to <html> element (e.g., <html lang="en">) for accessibility and search engines.'
+      };
+    }
+    const validLangPattern = /^[a-z]{2,3}(-[A-Z]{2})?$/;
+    if (!validLangPattern.test(langAttr.trim())) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 1,
+        maxScore: this.maxScore,
+        message: `Lang attribute present but may be invalid: "${langAttr}"`,
+        recommendation: 'Ensure lang attribute uses valid BCP-47 language code (e.g., "en", "en-US", "de").',
+        details: { langCode: langAttr }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 3,
+      maxScore: this.maxScore,
+      message: `Valid lang attribute: "${langAttr}"`,
+      details: { langCode: langAttr }
+    };
+  }
+};
+
+// src/rules/r14-https.ts
+var r14Https = {
+  id: "R14",
+  name: "HTTPS Enforcement",
+  description: "Verify that the page is served over secure HTTPS",
+  category: "technical",
+  maxScore: 3,
+  check(page) {
+    const isHttps = page.url.startsWith("https://");
+    if (!isHttps) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "Page is not served over HTTPS",
+        recommendation: "Enable HTTPS for your site. This is critical for security, SEO, and user trust.",
+        details: { protocol: "http" }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "pass",
+      score: 3,
+      maxScore: this.maxScore,
+      message: "Page is served over HTTPS",
+      details: { protocol: "https" }
+    };
+  }
+};
+var r15AltText = {
+  id: "R15",
+  name: "Image Alt Text Coverage",
+  description: "Check that images have descriptive alt text for accessibility and AI parsing",
+  category: "content-quality",
+  maxScore: 5,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const images = $("img");
+    const contentImages = [];
+    images.each((_, el) => {
+      const $el = $(el);
+      const role = $el.attr("role");
+      if (role !== "presentation") {
+        contentImages.push($el);
+      }
+    });
+    const totalImages = contentImages.length;
+    if (totalImages === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "pass",
+        score: 5,
+        maxScore: this.maxScore,
+        message: "No images found on page",
+        details: { totalImages: 0, imagesWithAlt: 0, percentage: 100 }
+      };
+    }
+    let imagesWithAlt = 0;
+    contentImages.forEach(($el) => {
+      const alt = $el.attr("alt");
+      if (alt !== void 0 && alt.trim() !== "") {
+        imagesWithAlt++;
+      }
+    });
+    const percentage = Math.round(imagesWithAlt / totalImages * 100);
+    if (percentage >= 90) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "pass",
+        score: 5,
+        maxScore: this.maxScore,
+        message: `${imagesWithAlt} of ${totalImages} images have alt text (${percentage}%)`,
+        details: { totalImages, imagesWithAlt, percentage }
+      };
+    }
+    if (percentage >= 50) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 3,
+        maxScore: this.maxScore,
+        message: `Only ${imagesWithAlt} of ${totalImages} images have alt text (${percentage}%)`,
+        recommendation: "Add descriptive alt text to all images. Alt text helps screen readers, SEO, and AI systems understand your images.",
+        details: { totalImages, imagesWithAlt, percentage }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "fail",
+      score: 0,
+      maxScore: this.maxScore,
+      message: `Only ${imagesWithAlt} of ${totalImages} images have alt text (${percentage}%)`,
+      recommendation: "Add descriptive alt text to all images. This is critical for accessibility and helps AI systems understand your content.",
+      details: { totalImages, imagesWithAlt, percentage }
+    };
+  }
+};
+var r16SemanticHtml = {
+  id: "R16",
+  name: "Semantic HTML",
+  description: "Check for semantic HTML5 elements (main, article, section, nav, etc.)",
+  category: "content-quality",
+  maxScore: 5,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const semanticElements = [
+      "main",
+      "article",
+      "section",
+      "nav",
+      "aside",
+      "header",
+      "footer"
+    ];
+    const foundElements = /* @__PURE__ */ new Set();
+    semanticElements.forEach((tag) => {
+      if ($(tag).length > 0) {
+        foundElements.add(tag);
+      }
+    });
+    const count = foundElements.size;
+    const elementList = Array.from(foundElements).sort().join(", ");
+    if (count >= 3) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "pass",
+        score: 5,
+        maxScore: this.maxScore,
+        message: `Good use of semantic HTML: ${elementList}`,
+        details: { semanticElements: Array.from(foundElements), count }
+      };
+    }
+    if (count >= 1) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 3,
+        maxScore: this.maxScore,
+        message: `Limited semantic HTML: ${elementList || "none"}`,
+        recommendation: "Use more semantic HTML5 elements (main, article, section, nav, aside, header, footer) to improve content structure for AI parsing and accessibility.",
+        details: { semanticElements: Array.from(foundElements), count }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "fail",
+      score: 0,
+      maxScore: this.maxScore,
+      message: "No semantic HTML5 elements found",
+      recommendation: "Replace generic <div> elements with semantic HTML5 elements like <main>, <article>, <section>, <nav>, <header>, and <footer> to help AI systems understand your content structure.",
+      details: { semanticElements: [], count: 0 }
+    };
+  }
+};
+var IDENTITY_TYPES = ["Organization", "Person", "LocalBusiness"];
+var r17IdentitySchema = {
+  id: "R17",
+  name: "Identity Schema Detection",
+  description: "Check for Organization, Person, or LocalBusiness schema in JSON-LD",
+  category: "structured-data",
+  maxScore: 5,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const scripts = $('script[type="application/ld+json"]');
+    if (scripts.length === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "No JSON-LD found on page",
+        recommendation: "Add JSON-LD with Organization, Person, or LocalBusiness schema to establish your identity for AI systems."
+      };
+    }
+    const types = [];
+    let hasJsonLd = false;
+    scripts.each((_, el) => {
+      const text = $(el).text();
+      try {
+        const data = JSON.parse(text);
+        hasJsonLd = true;
+        const extractType = (obj) => {
+          if (obj["@type"]) {
+            const t = Array.isArray(obj["@type"]) ? obj["@type"] : [obj["@type"]];
+            types.push(...t);
+          }
+          if (obj["@graph"] && Array.isArray(obj["@graph"])) {
+            for (const item of obj["@graph"]) {
+              extractType(item);
+            }
+          }
+        };
+        extractType(data);
+      } catch {
+      }
+    });
+    const identityTypes = types.filter((t) => IDENTITY_TYPES.includes(t));
+    if (identityTypes.length > 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "pass",
+        score: 5,
+        maxScore: this.maxScore,
+        message: `Identity schema found: ${identityTypes.join(", ")}`,
+        details: { types: identityTypes }
+      };
+    }
+    if (hasJsonLd) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 2,
+        maxScore: this.maxScore,
+        message: "JSON-LD exists but no identity schema found",
+        recommendation: "Add Organization, Person, or LocalBusiness schema to help AI systems understand who you are.",
+        details: { types }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "fail",
+      score: 0,
+      maxScore: this.maxScore,
+      message: "No valid JSON-LD found",
+      recommendation: "Add JSON-LD with Organization, Person, or LocalBusiness schema to establish your identity."
+    };
+  }
+};
+var r18RssFeed = {
+  id: "R18",
+  name: "RSS/Atom Feed Detection",
+  description: "Check for discoverable RSS or Atom feed links in HTML head",
+  category: "discoverability",
+  maxScore: 5,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const feedLinks = $('link[rel="alternate"]');
+    if (feedLinks.length === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "No feed link found",
+        recommendation: 'Add <link rel="alternate" type="application/rss+xml" href="/feed.xml"> to make your content discoverable via feeds.'
+      };
+    }
+    const rssFeeds = [];
+    const atomFeeds = [];
+    const otherFeeds = [];
+    feedLinks.each((_, el) => {
+      const type = $(el).attr("type");
+      const href = $(el).attr("href");
+      if (type === "application/rss+xml" && href) {
+        rssFeeds.push(href);
+      } else if (type === "application/atom+xml" && href) {
+        atomFeeds.push(href);
+      } else if (href) {
+        otherFeeds.push(href);
+      }
+    });
+    const validFeeds = rssFeeds.length + atomFeeds.length;
+    if (validFeeds > 0) {
+      const feedTypes = [];
+      if (rssFeeds.length > 0) feedTypes.push(`RSS (${rssFeeds.length})`);
+      if (atomFeeds.length > 0) feedTypes.push(`Atom (${atomFeeds.length})`);
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "pass",
+        score: 5,
+        maxScore: this.maxScore,
+        message: `Feed link(s) found: ${feedTypes.join(", ")}`,
+        details: { rssFeeds, atomFeeds }
+      };
+    }
+    if (otherFeeds.length > 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 2,
+        maxScore: this.maxScore,
+        message: "Feed link found but missing or incorrect type attribute",
+        recommendation: 'Set type="application/rss+xml" or type="application/atom+xml" on feed link elements.',
+        details: { otherFeeds }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "fail",
+      score: 0,
+      maxScore: this.maxScore,
+      message: "No valid feed link found",
+      recommendation: 'Add <link rel="alternate" type="application/rss+xml" href="/feed.xml"> for content discoverability.'
+    };
+  }
+};
+
+// src/rules/r19-llms-quality.ts
+var r19LlmsQuality = {
+  id: "R19",
+  name: "llms.txt Content Quality",
+  description: "Analyze the quality and completeness of llms.txt content",
+  category: "discoverability",
+  maxScore: 5,
+  check(page) {
+    const { llmsTxt } = page;
+    if (!llmsTxt.ok || llmsTxt.status !== 200) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "skip",
+        score: 5,
+        maxScore: this.maxScore,
+        message: "llms.txt does not exist (skipped)"
+      };
+    }
+    const body = llmsTxt.body.trim();
+    if (body.length === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "skip",
+        score: 5,
+        maxScore: this.maxScore,
+        message: "llms.txt is empty (skipped)"
+      };
+    }
+    let qualityScore = 0;
+    const signals = [];
+    if (/^#\s+.+/m.test(body)) {
+      qualityScore++;
+      signals.push("H1 heading");
+    }
+    if (body.length >= 100) {
+      qualityScore++;
+      signals.push("sufficient length");
+    }
+    if (/\[.+\]\(.+\)/m.test(body)) {
+      qualityScore++;
+      signals.push("contains links");
+    }
+    const h2Count = (body.match(/^##\s+.+/gm) || []).length;
+    if (h2Count >= 2) {
+      qualityScore++;
+      signals.push("multiple sections");
+    }
+    const nonHeadingLines = body.split("\n").filter((line) => !line.trim().startsWith("#") && line.trim().length > 0);
+    if (nonHeadingLines.length >= 3) {
+      qualityScore++;
+      signals.push("descriptive content");
+    }
+    if (qualityScore >= 4) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "pass",
+        score: 5,
+        maxScore: this.maxScore,
+        message: `High-quality llms.txt (${qualityScore}/5 signals): ${signals.join(", ")}`,
+        details: { qualityScore, signals }
+      };
+    }
+    if (qualityScore >= 2) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "warn",
+        score: 3,
+        maxScore: this.maxScore,
+        message: `llms.txt could be improved (${qualityScore}/5 signals)`,
+        recommendation: "Enhance llms.txt with: H1 heading, sufficient content (100+ chars), markdown links, multiple sections (## headings), and descriptive text.",
+        details: { qualityScore, signals }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "fail",
+      score: 1,
+      maxScore: this.maxScore,
+      message: `Minimal llms.txt quality (${qualityScore}/5 signals)`,
+      recommendation: "Improve llms.txt with: H1 heading, more content, markdown links, multiple sections, and descriptive paragraphs.",
+      details: { qualityScore, signals }
+    };
+  }
+};
+var r20Viewport = {
+  id: "R20",
+  name: "Mobile Viewport Meta Tag",
+  description: "Check for proper viewport meta tag for mobile responsiveness",
+  category: "technical",
+  maxScore: 3,
+  check(page) {
+    const $ = cheerio.load(page.html);
+    const viewport = $('meta[name="viewport"]');
+    if (viewport.length === 0) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "fail",
+        score: 0,
+        maxScore: this.maxScore,
+        message: "No viewport meta tag found",
+        recommendation: 'Add <meta name="viewport" content="width=device-width, initial-scale=1"> for proper mobile rendering.'
+      };
+    }
+    const content = viewport.attr("content") || "";
+    if (content.includes("width=device-width")) {
+      return {
+        id: this.id,
+        name: this.name,
+        description: this.description,
+        category: this.category,
+        status: "pass",
+        score: 3,
+        maxScore: this.maxScore,
+        message: "Viewport meta tag properly configured",
+        details: { content }
+      };
+    }
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description,
+      category: this.category,
+      status: "warn",
+      score: 1,
+      maxScore: this.maxScore,
+      message: "Viewport meta tag exists but missing width=device-width",
+      recommendation: 'Update viewport meta tag to include "width=device-width" for proper mobile responsiveness.',
+      details: { content }
+    };
+  }
+};
+
+// src/rules/index.ts
+var allRules = [
+  // AI Discoverability (40 pts)
+  r01LlmsTxt,
+  r02RobotsTxt,
+  r03Sitemap,
+  r18RssFeed,
+  r19LlmsQuality,
+  // Structured Data (35 pts)
+  r04JsonLd,
+  r05OpenGraph,
+  r06MetaDescription,
+  r07Canonical,
+  r17IdentitySchema,
+  // Content Quality (38 pts)
+  r08Headings,
+  r09SsrContent,
+  r10Faq,
+  r13LangTag,
+  r15AltText,
+  r16SemanticHtml,
+  // Technical AI-Readiness (21 pts)
+  r11ResponseTime,
+  r12ContentType,
+  r14Https,
+  r20Viewport
+];
+
+// src/score.ts
+var CATEGORY_DEFS = [
+  { name: "AI Discoverability", slug: "discoverability", maxPoints: 40 },
+  { name: "Structured Data", slug: "structured-data", maxPoints: 35 },
+  { name: "Content Quality", slug: "content-quality", maxPoints: 38 },
+  { name: "Technical AI-Readiness", slug: "technical", maxPoints: 21 }
+];
+new Map(CATEGORY_DEFS.map((c) => [c.slug, c]));
+function getGrade(score) {
+  if (score >= 90) return "A";
+  if (score >= 75) return "B";
+  if (score >= 60) return "C";
+  if (score >= 40) return "D";
+  return "F";
+}
+function buildCategories(results) {
+  return CATEGORY_DEFS.map((def) => {
+    const rules = results.filter((r) => r.category === def.slug);
+    const score = rules.reduce((sum, r) => sum + r.score, 0);
+    return {
+      name: def.name,
+      slug: def.slug,
+      maxPoints: def.maxPoints,
+      score: Math.min(score, def.maxPoints),
+      rules
+    };
+  });
+}
+function calculateScore(results) {
+  const totalMax = results.reduce((sum, r) => sum + r.maxScore, 0);
+  if (totalMax === 0) return 0;
+  const totalScore = results.reduce((sum, r) => sum + r.score, 0);
+  return Math.round(totalScore / totalMax * 100);
+}
+function buildRecommendations(results) {
+  return results.filter((r) => r.status !== "pass" && r.status !== "skip" && r.recommendation).map((r) => ({
+    rule: r.id,
+    message: r.recommendation,
+    impact: r.maxScore - r.score
+  })).sort((a, b) => b.impact - a.impact);
+}
+
+// src/audit.ts
+var VERSION = "0.1.0";
+async function audit(url, options = {}) {
+  const startTime = performance.now();
+  const pageData = await fetchPageData(url, options);
+  const results = [];
+  for (const rule of allRules) {
+    const result = await rule.check(pageData);
+    results.push(result);
+  }
+  const score = calculateScore(results);
+  const grade = getGrade(score);
+  const categories = buildCategories(results);
+  const recommendations = buildRecommendations(results);
+  const duration = Math.round(performance.now() - startTime);
+  return {
+    url: pageData.url,
+    score,
+    grade,
+    categories,
+    rules: results,
+    recommendations,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    duration,
+    version: VERSION
+  };
+}
+
+// src/cli.ts
+var VERSION2 = "0.1.0";
+function parseArgs(args) {
+  const flags = {};
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    switch (arg) {
+      case "--help":
+      case "-h":
+        flags.help = true;
+        break;
+      case "--version":
+      case "-v":
+      case "-V":
+        flags.version = true;
+        break;
+      case "--json":
+      case "-j":
+        flags.json = true;
+        break;
+      case "--verbose":
+        flags.verbose = true;
+        break;
+      case "--quiet":
+      case "-q":
+        flags.quiet = true;
+        break;
+      case "--debug":
+        flags.debug = true;
+        break;
+      case "--insecure":
+        flags.insecure = true;
+        break;
+      case "--no-recommendations":
+      case "--no-recs":
+        flags.noRecommendations = true;
+        break;
+      case "--fail-under": {
+        i++;
+        const val = args[i];
+        if (val === void 0 || isNaN(Number(val))) {
+          console.error(chalk.red("Error: --fail-under requires a numeric value"));
+          process.exit(1);
+        }
+        flags.failUnder = Number(val);
+        break;
+      }
+      case "--timeout": {
+        i++;
+        const val = args[i];
+        if (val === void 0 || isNaN(Number(val))) {
+          console.error(chalk.red("Error: --timeout requires a numeric value"));
+          process.exit(1);
+        }
+        flags.timeout = Number(val);
+        break;
+      }
+      default:
+        if (!arg.startsWith("-")) {
+          flags.url = arg;
+        } else {
+          console.error(chalk.red(`Unknown flag: ${arg}`));
+          process.exit(1);
+        }
+    }
+    i++;
+  }
+  return flags;
+}
+function printHelp() {
+  console.log(`
+${chalk.bold("geo-audit")} \u2014 Audit any website's AI-readiness
+
+${chalk.dim("USAGE")}
+  npx geo-audit <url> [options]
+  echo "https://example.com" | npx geo-audit [options]
+
+${chalk.dim("OPTIONS")}
+  ${chalk.cyan("--json, -j")}        Output results as JSON
+  ${chalk.cyan("--verbose")}         Show all rules including passed ones
+  ${chalk.cyan("--quiet, -q")}       Only show score and grade
+  ${chalk.cyan("--fail-under <n>")}  Exit code 2 if score is below threshold
+  ${chalk.cyan("--no-recommendations, --no-recs")}
+                        Skip recommendations section
+  ${chalk.cyan("--timeout <ms>")}    Override default 10s fetch timeout
+  ${chalk.cyan("--insecure")}        Skip SSL verification
+  ${chalk.cyan("--debug")}           Show debug information
+  ${chalk.cyan("--help, -h")}        Show this help message
+  ${chalk.cyan("--version, -v, -V")} Show version
+
+${chalk.dim("EXIT CODES")}
+  0  Success
+  1  Error (DNS, timeout, network)
+  2  Score below --fail-under threshold
+
+${chalk.dim("EXAMPLES")}
+  npx geo-audit https://example.com
+  npx geo-audit example.com --json
+  npx geo-audit example.com --fail-under 80
+  npx geo-audit example.com --timeout 20000 --no-recs
+
+${chalk.dim("Powered by GeoKit \u2014 geo.glincker.com")}
+`);
+}
+function statusIcon(status) {
+  switch (status) {
+    case "pass":
+      return chalk.green("  \u2705");
+    case "warn":
+      return chalk.yellow("  \u26A0\uFE0F ");
+    case "fail":
+      return chalk.red("  \u274C");
+    case "skip":
+      return chalk.dim("  \u2796");
+    default:
+      return "  ";
+  }
+}
+function gradeColor(grade) {
+  switch (grade) {
+    case "A":
+      return chalk.green;
+    case "B":
+      return chalk.greenBright;
+    case "C":
+      return chalk.yellow;
+    case "D":
+      return chalk.redBright;
+    case "F":
+      return chalk.red;
+    default:
+      return chalk.white;
+  }
+}
+function printCategory(cat, verbose) {
+  const pct = cat.maxPoints > 0 ? Math.round(cat.score / cat.maxPoints * 100) : 0;
+  const color = pct >= 80 ? chalk.green : pct >= 50 ? chalk.yellow : chalk.red;
+  console.log(
+    `
+${chalk.bold(cat.name)}${chalk.dim(`  ${color(`${cat.score}/${cat.maxPoints}`)}`)}`
+  );
+  for (const rule of cat.rules) {
+    if (!verbose && rule.status === "pass") continue;
+    printRule(rule);
+  }
+}
+function printRule(rule) {
+  const icon = statusIcon(rule.status);
+  const score = chalk.dim(`${rule.score}/${rule.maxScore}`);
+  console.log(`${icon} ${rule.name}  ${score}`);
+  if (rule.status !== "pass" && rule.status !== "skip") {
+    console.log(chalk.dim(`     ${rule.message}`));
+  }
+}
+function printResult(result, flags) {
+  const colorFn = gradeColor(result.grade);
+  const hostname = new URL(result.url).hostname;
+  console.log(`
+${chalk.bold("\u{1F50D} GEO Audit:")} ${hostname}`);
+  console.log(chalk.dim("\u2501".repeat(40)));
+  console.log(
+    `
+Score: ${colorFn(chalk.bold(`${result.score}/100`))} (${colorFn(result.grade)})`
+  );
+  if (flags.quiet) {
+    return;
+  }
+  for (const cat of result.categories) {
+    printCategory(cat, flags.verbose ?? false);
+  }
+  if (!flags.noRecommendations && result.recommendations.length > 0) {
+    console.log(`
+${chalk.bold("\u{1F4CB} Top Recommendations:")}`);
+    const top = result.recommendations.slice(0, 5);
+    for (let i = 0; i < top.length; i++) {
+      const rec = top[i];
+      console.log(
+        `  ${chalk.cyan(`${i + 1}.`)} ${rec.message} ${chalk.dim(`(+${rec.impact} points)`)}`
+      );
+    }
+  }
+  console.log(
+    `
+${chalk.dim(`Completed in ${result.duration}ms`)}`
+  );
+  console.log(chalk.dim("Powered by GeoKit \u2014 geo.glincker.com\n"));
+}
+async function main() {
+  if (process.env.NO_COLOR !== void 0 || process.env.FORCE_COLOR === "0") {
+    chalk.level = 0;
+  }
+  const args = process.argv.slice(2);
+  const flags = parseArgs(args);
+  if (flags.version) {
+    console.log(VERSION2);
+    return;
+  }
+  if (flags.help) {
+    printHelp();
+    return;
+  }
+  if (!flags.url && !process.stdin.isTTY) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    flags.url = Buffer.concat(chunks).toString().trim();
+  }
+  if (!flags.url) {
+    printHelp();
+    return;
+  }
+  let spinnerInterval = null;
+  process.on("SIGINT", () => {
+    if (spinnerInterval) {
+      clearInterval(spinnerInterval);
+    }
+    process.stderr.write("\r" + " ".repeat(60) + "\r");
+    process.exit(130);
+  });
+  const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  let frameIdx = 0;
+  spinnerInterval = setInterval(() => {
+    process.stderr.write(`\r${chalk.cyan(frames[frameIdx % frames.length])} Auditing ${flags.url}...`);
+    frameIdx++;
+  }, 80);
+  try {
+    const result = await audit(flags.url, {
+      insecure: flags.insecure,
+      timeout: flags.timeout
+    });
+    clearInterval(spinnerInterval);
+    spinnerInterval = null;
+    process.stderr.write("\r" + " ".repeat(60) + "\r");
+    if (flags.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      printResult(result, flags);
+    }
+    if (flags.failUnder !== void 0 && result.score < flags.failUnder) {
+      process.exit(2);
+    }
+  } catch (error) {
+    if (spinnerInterval) {
+      clearInterval(spinnerInterval);
+    }
+    process.stderr.write("\r" + " ".repeat(60) + "\r");
+    if (flags.debug) {
+      console.error(error);
+    }
+    const message = error instanceof Error ? error.message : "Unknown error";
+    if (message.includes("ENOTFOUND") || message.includes("getaddrinfo")) {
+      console.error(
+        chalk.red(`Could not resolve hostname. Check the URL and try again.`)
+      );
+    } else if (message.includes("abort") || message.includes("timeout")) {
+      console.error(
+        chalk.red(
+          `Request timed out. The site may be slow or blocking requests.`
+        )
+      );
+    } else if (message.includes("SSL") || message.includes("certificate")) {
+      console.error(
+        chalk.red(
+          `SSL certificate error. Try with --insecure (not recommended).`
+        )
+      );
+    } else if (message.includes("Blocked")) {
+      console.error(chalk.red(message));
+    } else {
+      console.error(chalk.red(`Error: ${message}`));
+    }
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map