geo-checker 1.0.0

package/dist/cli.js

@@ -0,0 +1,1420 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command, CommanderError } from "commander";
+import { pathToFileURL } from "url";
+
+// src/data/ai-bots.ts
+var aiBots = [
+  {
+    name: "GPTBot",
+    userAgent: "GPTBot",
+    company: "OpenAI",
+    purpose: "Both",
+    docsUrl: "https://platform.openai.com/docs/bots"
+  },
+  {
+    name: "OAI-SearchBot",
+    userAgent: "OAI-SearchBot",
+    company: "OpenAI",
+    purpose: "Search",
+    docsUrl: "https://platform.openai.com/docs/bots"
+  },
+  {
+    name: "ChatGPT-User",
+    userAgent: "ChatGPT-User",
+    company: "OpenAI",
+    purpose: "Browse",
+    docsUrl: "https://platform.openai.com/docs/bots"
+  },
+  {
+    name: "ClaudeBot",
+    userAgent: "ClaudeBot",
+    company: "Anthropic",
+    purpose: "Training",
+    docsUrl: "https://support.anthropic.com/en/articles/8896518"
+  },
+  {
+    name: "anthropic-ai",
+    userAgent: "anthropic-ai",
+    company: "Anthropic",
+    purpose: "Training",
+    docsUrl: "https://support.anthropic.com/en/articles/8896518"
+  },
+  {
+    name: "PerplexityBot",
+    userAgent: "PerplexityBot",
+    company: "Perplexity",
+    purpose: "Search",
+    docsUrl: "https://docs.perplexity.ai/docs/perplexitybot"
+  },
+  {
+    name: "Google-Extended",
+    userAgent: "Google-Extended",
+    company: "Google",
+    purpose: "Training",
+    docsUrl: "https://developers.google.com/search/docs/crawling-indexing/google-common-crawlers"
+  },
+  {
+    name: "Googlebot",
+    userAgent: "Googlebot",
+    company: "Google",
+    purpose: "Reference",
+    docsUrl: "https://developers.google.com/search/docs/crawling-indexing/google-common-crawlers"
+  },
+  {
+    name: "Bytespider",
+    userAgent: "Bytespider",
+    company: "ByteDance",
+    purpose: "Training",
+    docsUrl: "https://www.bytedance.com/en/robot"
+  },
+  {
+    name: "CCBot",
+    userAgent: "CCBot",
+    company: "Common Crawl",
+    purpose: "Training",
+    docsUrl: "https://commoncrawl.org/ccbot"
+  },
+  {
+    name: "FacebookBot",
+    userAgent: "FacebookBot",
+    company: "Meta",
+    purpose: "Training",
+    docsUrl: "https://developers.facebook.com/docs/sharing/webmasters/web-crawlers"
+  },
+  {
+    name: "Meta-ExternalAgent",
+    userAgent: "Meta-ExternalAgent",
+    company: "Meta",
+    purpose: "Training",
+    docsUrl: "https://developers.facebook.com/docs/sharing/webmasters/web-crawlers"
+  },
+  {
+    name: "Amazonbot",
+    userAgent: "Amazonbot",
+    company: "Amazon",
+    purpose: "Training",
+    docsUrl: "https://developer.amazon.com/support/amazonbot"
+  },
+  {
+    name: "Cohere-ai",
+    userAgent: "cohere-ai",
+    company: "Cohere",
+    purpose: "Training",
+    docsUrl: "https://docs.cohere.com/docs/crawlers"
+  },
+  {
+    name: "YouBot",
+    userAgent: "YouBot",
+    company: "You.com",
+    purpose: "Search",
+    docsUrl: "https://about.you.com/youbot/"
+  },
+  {
+    name: "Applebot-Extended",
+    userAgent: "Applebot-Extended",
+    company: "Apple",
+    purpose: "Training",
+    docsUrl: "https://support.apple.com/en-us/119829"
+  },
+  {
+    name: "Diffbot",
+    userAgent: "Diffbot",
+    company: "Diffbot",
+    purpose: "Training",
+    docsUrl: "https://docs.diffbot.com/docs/using-robots-txt"
+  }
+];
+
+// src/analyzers/geo-score.ts
+import { load } from "cheerio";
+
+// src/analyzers/bot-access.ts
+function calculateBotAccessPoints(robots) {
+  const { allowed, notMentioned, partiallyBlocked, totalBots } = robots.summary;
+  if (totalBots === 0) {
+    return 0;
+  }
+  const ratio = (allowed + notMentioned + partiallyBlocked * 0.5) / totalBots;
+  return Math.round(10 * ratio);
+}
+function buildBotAccessCheck(robots) {
+  const points = calculateBotAccessPoints(robots);
+  const allowedEquivalent = robots.summary.allowed + robots.summary.notMentioned + robots.summary.partiallyBlocked * 0.5;
+  return {
+    id: "ai.bots_access",
+    name: "AI bots allowed in robots.txt",
+    passed: points >= 7,
+    points,
+    maxPoints: 10,
+    detail: `${allowedEquivalent.toFixed(1)} of ${robots.summary.totalBots} bots counted as allowed-equivalent`,
+    fix: "Allow strategic AI bots in robots.txt while explicitly documenting bot policy."
+  };
+}
+function buildSitemapCheck(robots) {
+  const hasSitemap = robots.sitemaps.length > 0;
+  return {
+    id: "ai.sitemap_reference",
+    name: "Sitemap.xml referenced in robots.txt",
+    passed: hasSitemap,
+    points: hasSitemap ? 3 : 0,
+    maxPoints: 3,
+    detail: hasSitemap ? `Found ${robots.sitemaps.length} sitemap reference(s)` : "No sitemap reference found in robots.txt",
+    fix: "Add a Sitemap directive in robots.txt (e.g., Sitemap: https://example.com/sitemap.xml)."
+  };
+}
+function buildNotMentionedRecommendation(robots) {
+  if (robots.summary.notMentioned === 0) {
+    return null;
+  }
+  return {
+    priority: "low",
+    category: "AI Accessibility",
+    message: `${robots.summary.notMentioned} AI bot(s) are not explicitly mentioned in robots.txt. Add explicit rules to remove ambiguity.`,
+    impact: "No score impact",
+    checkId: "ai.bots_explicit_policy"
+  };
+}
+
+// src/analyzers/content-quality.ts
+function countWords(text) {
+  const normalized = text.replace(/\s+/g, " ").trim();
+  if (!normalized) {
+    return 0;
+  }
+  return normalized.split(" ").length;
+}
+function isHeadingHierarchyLogical($) {
+  const headings = $("h1,h2,h3,h4,h5,h6").toArray();
+  let lastLevel = 0;
+  for (const heading of headings) {
+    const tag = heading.tagName?.toLowerCase();
+    if (!tag || !/^h[1-6]$/.test(tag)) {
+      continue;
+    }
+    const currentLevel = Number(tag.slice(1));
+    if (lastLevel > 0 && currentLevel > lastLevel + 1) {
+      return false;
+    }
+    lastLevel = currentLevel;
+  }
+  return true;
+}
+function analyzeLinks($, pageUrl) {
+  const currentHost = new URL(pageUrl).hostname;
+  let internal = 0;
+  let external = 0;
+  for (const anchor of $("a[href]").toArray()) {
+    const href = $(anchor).attr("href")?.trim();
+    if (!href) {
+      continue;
+    }
+    if (href.startsWith("#") || href.startsWith("mailto:") || href.startsWith("tel:")) {
+      continue;
+    }
+    try {
+      const target = new URL(href, pageUrl);
+      if (target.hostname === currentHost) {
+        internal += 1;
+      } else {
+        external += 1;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return { internal, external };
+}
+function analyzeContentQuality($, pageUrl) {
+  const bodyText = $("body").text();
+  const wordCount = countWords(bodyText);
+  const paragraphWordCounts = $("p").toArray().map((paragraph) => countWords($(paragraph).text())).filter((words) => words > 0);
+  const avgParagraphWords = paragraphWordCounts.length === 0 ? 0 : paragraphWordCounts.reduce((sum, words) => sum + words, 0) / paragraphWordCounts.length;
+  const links = analyzeLinks($, pageUrl);
+  const hasAuthorSignal = $("[rel='author']").length > 0 || $("[itemprop='author']").length > 0 || $("meta[name='author']").length > 0 || $("[class*='author' i]").length > 0;
+  const hasTablesWithHeaders = $("table").toArray().some((table) => $(table).find("th").length > 0);
+  return {
+    h1Count: $("h1").length,
+    headingHierarchyLogical: isHeadingHierarchyLogical($),
+    wordCount,
+    avgParagraphWords,
+    hasLists: $("ul li,ol li").length > 0,
+    hasTablesWithHeaders,
+    internalLinks: links.internal,
+    externalLinks: links.external,
+    hasAuthorSignal,
+    hasMeaningfulHtmlContent: wordCount >= 120
+  };
+}
+
+// src/analyzers/meta-tags.ts
+var REQUIRED_OG_TAGS = ["og:title", "og:description", "og:image", "og:type"];
+function getMetaContent($, selector) {
+  const value = $(selector).attr("content")?.trim();
+  return value || void 0;
+}
+function hasDirective(value, directive) {
+  if (!value) {
+    return false;
+  }
+  return value.toLowerCase().split(",").map((entry) => entry.trim()).includes(directive);
+}
+function analyzeMetaTags($) {
+  const ogMissing = REQUIRED_OG_TAGS.filter((tag) => !getMetaContent($, `meta[property='${tag}']`));
+  const canonicalUrl = $("link[rel='canonical']").attr("href")?.trim();
+  const viewport = getMetaContent($, "meta[name='viewport']");
+  const robots = getMetaContent($, "meta[name='robots']");
+  const googleBot = getMetaContent($, "meta[name='googlebot']");
+  const noaiMeta = getMetaContent($, "meta[name='noai']");
+  const noImageAiMeta = getMetaContent($, "meta[name='noimageai']");
+  const publicationDate = getMetaContent($, "meta[property='article:published_time']") ?? getMetaContent($, "meta[name='datePublished']") ?? $("time[datetime]").first().attr("datetime")?.trim();
+  const modifiedDate = getMetaContent($, "meta[property='article:modified_time']") ?? getMetaContent($, "meta[name='last-modified']") ?? getMetaContent($, "meta[name='dateModified']");
+  const hasMetaAuthor = !!getMetaContent($, "meta[name='author']") || $("link[rel='author']").length > 0 || !!getMetaContent($, "meta[property='article:author']");
+  return {
+    ogTagsPresent: ogMissing.length === 0,
+    ogMissing,
+    hasCanonical: !!canonicalUrl,
+    canonicalUrl,
+    hasViewport: !!viewport,
+    hasNoAiDirectives: hasDirective(robots, "noai") || hasDirective(robots, "noimageai") || hasDirective(googleBot, "noai") || hasDirective(googleBot, "noimageai") || !!noaiMeta || !!noImageAiMeta,
+    publicationDate,
+    modifiedDate,
+    hasMetaAuthor
+  };
+}
+
+// src/analyzers/structured-data.ts
+function normalizeType(value) {
+  if (typeof value === "string") {
+    return [value];
+  }
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item === "string");
+  }
+  return [];
+}
+function walkJsonLd(node, ctx) {
+  if (!node) {
+    return;
+  }
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      walkJsonLd(child, ctx);
+    }
+    return;
+  }
+  if (typeof node !== "object") {
+    return;
+  }
+  const record = node;
+  for (const typeName of normalizeType(record["@type"])) {
+    ctx.types.add(typeName);
+    if (typeName.toLowerCase() === "organization") {
+      ctx.hasOrganization = true;
+    }
+  }
+  if (record.author !== void 0) {
+    ctx.hasAuthor = true;
+  }
+  if (record.datePublished !== void 0) {
+    ctx.hasDatePublished = true;
+  }
+  if (record.dateModified !== void 0 || record.modifiedTime !== void 0) {
+    ctx.hasDateModified = true;
+  }
+  for (const value of Object.values(record)) {
+    walkJsonLd(value, ctx);
+  }
+}
+function analyzeStructuredData($) {
+  const scripts = $("script[type='application/ld+json']").toArray();
+  const types = /* @__PURE__ */ new Set();
+  let validCount = 0;
+  let invalidCount = 0;
+  const ctx = {
+    types,
+    hasOrganization: false,
+    hasAuthor: false,
+    hasDatePublished: false,
+    hasDateModified: false
+  };
+  for (const script of scripts) {
+    const payload = $(script).text().trim();
+    if (!payload) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(payload);
+      validCount += 1;
+      walkJsonLd(parsed, ctx);
+    } catch {
+      invalidCount += 1;
+    }
+  }
+  return {
+    hasJsonLd: scripts.length > 0,
+    validJsonLd: scripts.length > 0 && validCount > 0 && invalidCount === 0,
+    schemaTypes: [...types].sort((a, b) => a.localeCompare(b)),
+    hasOrganizationSchema: ctx.hasOrganization,
+    hasAuthorProperty: ctx.hasAuthor,
+    hasDatePublished: ctx.hasDatePublished,
+    hasDateModified: ctx.hasDateModified
+  };
+}
+
+// src/analyzers/technical.ts
+function analyzeTechnical(input) {
+  return {
+    isHttps: input.finalUrl.startsWith("https://"),
+    loadUnder3Seconds: input.loadTimeMs < 3e3
+  };
+}
+
+// src/scoring/calculator.ts
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+function priorityFromMissing(missingPoints) {
+  if (missingPoints >= 5) {
+    return "high";
+  }
+  if (missingPoints >= 3) {
+    return "medium";
+  }
+  return "low";
+}
+function calculateCategoryScore(checks, maxScore) {
+  const score = clamp(
+    checks.reduce((sum, check2) => sum + check2.points, 0),
+    0,
+    maxScore
+  );
+  return {
+    score,
+    maxScore,
+    checks
+  };
+}
+function calculateGrade(total) {
+  if (total >= 95) {
+    return "A+";
+  }
+  if (total >= 90) {
+    return "A";
+  }
+  if (total >= 80) {
+    return "B+";
+  }
+  if (total >= 70) {
+    return "B";
+  }
+  if (total >= 60) {
+    return "C";
+  }
+  if (total >= 40) {
+    return "D";
+  }
+  return "F";
+}
+function recommendationsFromChecks(checksByCategory) {
+  const recommendations = [];
+  for (const item of checksByCategory) {
+    for (const check2 of item.checks) {
+      const missingPoints = check2.maxPoints - check2.points;
+      if (missingPoints <= 0) {
+        continue;
+      }
+      recommendations.push({
+        priority: priorityFromMissing(missingPoints),
+        category: item.category,
+        message: check2.fix ?? `Improve ${check2.name}.`,
+        impact: `+${missingPoints} points`,
+        checkId: check2.id
+      });
+    }
+  }
+  return recommendations.sort((left, right) => {
+    const leftImpact = Number.parseInt(left.impact.replace(/[^0-9]/g, ""), 10) || 0;
+    const rightImpact = Number.parseInt(right.impact.replace(/[^0-9]/g, ""), 10) || 0;
+    if (leftImpact !== rightImpact) {
+      return rightImpact - leftImpact;
+    }
+    const order = { high: 0, medium: 1, low: 2 };
+    return order[left.priority] - order[right.priority];
+  });
+}
+
+// src/analyzers/geo-score.ts
+var RELEVANT_SCHEMA_TYPES = ["Article", "FAQPage", "HowTo", "Product", "Organization"];
+function hasType(types, target) {
+  return types.some((type) => type.toLowerCase() === target.toLowerCase());
+}
+function check(id, name, points, maxPoints, detail, fix) {
+  return {
+    id,
+    name,
+    passed: points >= maxPoints,
+    points,
+    maxPoints,
+    detail,
+    fix
+  };
+}
+function analyzeGeoScore(input) {
+  const $ = load(input.html || "");
+  const structured = analyzeStructuredData($);
+  const meta = analyzeMetaTags($);
+  const content = analyzeContentQuality($, input.finalUrl);
+  const technical = analyzeTechnical({ finalUrl: input.finalUrl, loadTimeMs: input.loadTimeMs });
+  const matchedSchemaCount = RELEVANT_SCHEMA_TYPES.filter(
+    (schemaType) => hasType(structured.schemaTypes, schemaType)
+  ).length;
+  const structuredChecks = [
+    check(
+      "structured.jsonld_present",
+      "JSON-LD present",
+      structured.hasJsonLd ? 8 : 0,
+      8,
+      structured.hasJsonLd ? "Found JSON-LD script blocks." : "No JSON-LD script detected.",
+      "Add JSON-LD structured data to key pages."
+    ),
+    check(
+      "structured.schema_types",
+      "Relevant Schema.org types",
+      Math.min(10, matchedSchemaCount * 5),
+      10,
+      matchedSchemaCount > 0 ? `Found relevant schema types: ${RELEVANT_SCHEMA_TYPES.filter((schemaType) => hasType(structured.schemaTypes, schemaType)).join(", ")}` : "No relevant schema types found (Article, FAQPage, HowTo, Product, Organization).",
+      "Add relevant Schema.org types (Article, FAQPage, HowTo, Product, Organization)."
+    ),
+    check(
+      "structured.jsonld_valid",
+      "Valid JSON-LD syntax",
+      structured.validJsonLd ? 2 : 0,
+      2,
+      structured.validJsonLd ? "All JSON-LD blocks parsed successfully." : "JSON-LD missing or contains parse errors.",
+      "Validate JSON-LD with a schema validator and fix parse errors."
+    ),
+    check(
+      "structured.opengraph",
+      "OpenGraph tags present",
+      meta.ogTagsPresent ? 5 : 0,
+      5,
+      meta.ogTagsPresent ? "Found core OpenGraph tags (title, description, image, type)." : `Missing OpenGraph tags: ${meta.ogMissing.join(", ")}`,
+      "Add complete OpenGraph tags: og:title, og:description, og:image, og:type."
+    )
+  ];
+  const contentChecks = [
+    check(
+      "content.h1_single",
+      "Single H1 present",
+      content.h1Count === 1 ? 5 : 0,
+      5,
+      content.h1Count === 1 ? "Exactly one H1 found." : `Found ${content.h1Count} H1 elements.`,
+      "Ensure each page has exactly one descriptive H1."
+    ),
+    check(
+      "content.heading_hierarchy",
+      "Logical heading hierarchy",
+      content.headingHierarchyLogical ? 5 : 0,
+      5,
+      content.headingHierarchyLogical ? "Heading levels are sequential." : "Detected skipped heading levels (e.g., H2 to H4).",
+      "Use sequential heading levels without skipping (H1 \u2192 H2 \u2192 H3)."
+    ),
+    check(
+      "content.length_300_words",
+      "Content length over 300 words",
+      content.wordCount > 300 ? 3 : 0,
+      3,
+      `Detected ${content.wordCount} words.`,
+      "Expand the page content to exceed 300 words of useful text."
+    ),
+    check(
+      "content.short_paragraphs",
+      "Average paragraph length under 150 words",
+      content.avgParagraphWords > 0 && content.avgParagraphWords < 150 ? 3 : 0,
+      3,
+      `Average paragraph length is ${content.avgParagraphWords.toFixed(1)} words.`,
+      "Break long paragraphs into shorter blocks for readability."
+    ),
+    check(
+      "content.lists_present",
+      "Bullet or numbered lists present",
+      content.hasLists ? 2 : 0,
+      2,
+      content.hasLists ? "Found list elements." : "No bullet/numbered lists found.",
+      "Use bullet or numbered lists to structure key points."
+    ),
+    check(
+      "content.tables_with_headers",
+      "Tables with headers present",
+      content.hasTablesWithHeaders ? 2 : 0,
+      2,
+      content.hasTablesWithHeaders ? "Found table(s) with header cells." : "No data tables with headers detected.",
+      "Add tables with <th> headers when presenting structured comparisons."
+    ),
+    check(
+      "content.internal_links",
+      "Internal links present",
+      content.internalLinks > 0 ? 3 : 0,
+      3,
+      `Found ${content.internalLinks} internal links.`,
+      "Add links to relevant internal pages to improve crawl pathways."
+    ),
+    check(
+      "content.external_links",
+      "External authoritative links present",
+      content.externalLinks > 0 ? 2 : 0,
+      2,
+      `Found ${content.externalLinks} external links.`,
+      "Add links to authoritative external sources where relevant."
+    )
+  ];
+  const authorityChecks = [
+    check(
+      "authority.author_signal",
+      "Author name or bio present",
+      content.hasAuthorSignal || meta.hasMetaAuthor || structured.hasAuthorProperty ? 6 : 0,
+      6,
+      content.hasAuthorSignal || meta.hasMetaAuthor || structured.hasAuthorProperty ? "Detected author signals in page markup." : "No author information detected.",
+      "Add an author name/bio and include structured author metadata."
+    ),
+    check(
+      "authority.publication_date",
+      "Publication date present",
+      meta.publicationDate || structured.hasDatePublished ? 5 : 0,
+      5,
+      meta.publicationDate || structured.hasDatePublished ? `Publication date detected${meta.publicationDate ? ` (${meta.publicationDate})` : " in schema"}.` : "No publication date detected.",
+      "Add datePublished in schema or article meta tags."
+    ),
+    check(
+      "authority.last_modified",
+      "Last modified date present",
+      meta.modifiedDate || structured.hasDateModified ? 4 : 0,
+      4,
+      meta.modifiedDate || structured.hasDateModified ? `Last modified date detected${meta.modifiedDate ? ` (${meta.modifiedDate})` : " in schema"}.` : "No last modified date detected.",
+      "Add dateModified / article:modified_time metadata."
+    ),
+    check(
+      "authority.canonical",
+      "Canonical URL set",
+      meta.hasCanonical ? 4 : 0,
+      4,
+      meta.hasCanonical ? `Canonical URL: ${meta.canonicalUrl}` : "No canonical URL found.",
+      "Add a canonical link tag to avoid duplicate-content ambiguity."
+    ),
+    check(
+      "authority.https",
+      "HTTPS enabled",
+      technical.isHttps ? 3 : 0,
+      3,
+      technical.isHttps ? "Page is served via HTTPS." : "Page is not served via HTTPS.",
+      "Serve pages over HTTPS."
+    ),
+    check(
+      "authority.organization_schema",
+      "Organization schema present",
+      structured.hasOrganizationSchema ? 3 : 0,
+      3,
+      structured.hasOrganizationSchema ? "Organization schema detected." : "No Organization schema detected.",
+      "Add Organization schema to establish publisher identity."
+    )
+  ];
+  const aiChecks = [
+    buildBotAccessCheck(input.robots),
+    check(
+      "ai.no_noai_tags",
+      "No noai/noimageai directives",
+      meta.hasNoAiDirectives ? 0 : 3,
+      3,
+      meta.hasNoAiDirectives ? "Detected noai/noimageai directives that may block AI usage." : "No restrictive noai/noimageai directives found.",
+      "Remove noai/noimageai directives if you want AI systems to cite your content."
+    ),
+    buildSitemapCheck(input.robots),
+    check(
+      "ai.load_under_3s",
+      "Page loads under 3 seconds",
+      technical.loadUnder3Seconds ? 3 : 0,
+      3,
+      `Measured load time: ${input.loadTimeMs}ms.`,
+      "Improve server and asset performance to stay below 3 seconds."
+    ),
+    check(
+      "ai.viewport_meta",
+      "Mobile viewport meta present",
+      meta.hasViewport ? 3 : 0,
+      3,
+      meta.hasViewport ? "Viewport meta tag present." : "Viewport meta tag missing.",
+      'Add <meta name="viewport" content="width=device-width, initial-scale=1">.'
+    ),
+    check(
+      "ai.meaningful_html_content",
+      "Meaningful raw HTML content present",
+      content.hasMeaningfulHtmlContent ? 3 : 0,
+      3,
+      content.hasMeaningfulHtmlContent ? `Raw HTML includes ${content.wordCount} words of visible text.` : "Raw HTML has limited visible text and may rely on client-side rendering.",
+      "Ensure important content is rendered in raw HTML, not only via JavaScript."
+    )
+  ];
+  const structuredData = calculateCategoryScore(structuredChecks, 25);
+  const contentStructure = calculateCategoryScore(contentChecks, 25);
+  const authoritySignals = calculateCategoryScore(authorityChecks, 25);
+  const aiAccessibility = calculateCategoryScore(aiChecks, 25);
+  const total = structuredData.score + contentStructure.score + authoritySignals.score + aiAccessibility.score;
+  const recommendations = recommendationsFromChecks([
+    { category: "Structured Data", checks: structuredChecks },
+    { category: "Content Structure", checks: contentChecks },
+    { category: "Authority Signals", checks: authorityChecks },
+    { category: "AI Accessibility", checks: aiChecks }
+  ]);
+  const notMentionedWarning = buildNotMentionedRecommendation(input.robots);
+  if (notMentionedWarning) {
+    recommendations.push(notMentionedWarning);
+  }
+  return {
+    total,
+    grade: calculateGrade(total),
+    categories: {
+      structuredData,
+      contentStructure,
+      authoritySignals,
+      aiAccessibility
+    },
+    recommendations: recommendations.sort((left, right) => {
+      const leftScore = Number.parseInt(left.impact.replace(/[^0-9]/g, ""), 10) || 0;
+      const rightScore = Number.parseInt(right.impact.replace(/[^0-9]/g, ""), 10) || 0;
+      if (leftScore !== rightScore) {
+        return rightScore - leftScore;
+      }
+      const order = { high: 0, medium: 1, low: 2 };
+      return order[left.priority] - order[right.priority];
+    })
+  };
+}
+
+// src/scanner/http.ts
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+async function fetchWithRedirects(initialUrl, options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  let currentUrl = initialUrl;
+  for (let redirects = 0; redirects <= options.maxRedirects; redirects += 1) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), options.timeoutMs);
+    try {
+      const response = await fetchImpl(currentUrl, {
+        method: "GET",
+        redirect: "manual",
+        signal: controller.signal,
+        headers: {
+          "user-agent": "geo-check/1.0.0",
+          accept: "text/html,text/plain,*/*",
+          ...options.headers
+        }
+      });
+      if (!REDIRECT_STATUSES.has(response.status)) {
+        return { response, finalUrl: currentUrl };
+      }
+      const location = response.headers.get("location");
+      if (!location) {
+        return { response, finalUrl: currentUrl };
+      }
+      if (redirects === options.maxRedirects) {
+        throw new Error(`Too many redirects (>${options.maxRedirects})`);
+      }
+      currentUrl = new URL(location, currentUrl).toString();
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  throw new Error(`Too many redirects (>${options.maxRedirects})`);
+}
+
+// src/scanner/robots.ts
+function normalizeLine(line) {
+  const hashIndex = line.indexOf("#");
+  const withoutComment = hashIndex >= 0 ? line.slice(0, hashIndex) : line;
+  return withoutComment.trim();
+}
+function parseDirective(line) {
+  const colon = line.indexOf(":");
+  if (colon <= 0) {
+    return null;
+  }
+  const key = line.slice(0, colon).trim().toLowerCase();
+  const value = line.slice(colon + 1).trim();
+  if (!key) {
+    return null;
+  }
+  return { key, value };
+}
+function parseRobotsTxt(content) {
+  const groups = [];
+  const sitemaps = [];
+  let currentGroup = null;
+  let hasRuleInCurrentGroup = false;
+  const lines = content.split(/\r?\n/);
+  for (const rawLine of lines) {
+    const line = normalizeLine(rawLine);
+    if (!line) {
+      continue;
+    }
+    const parsed = parseDirective(line);
+    if (!parsed) {
+      continue;
+    }
+    if (parsed.key === "user-agent") {
+      const userAgent = parsed.value.toLowerCase();
+      if (!userAgent) {
+        continue;
+      }
+      if (!currentGroup || hasRuleInCurrentGroup) {
+        currentGroup = { userAgents: [], rules: [] };
+        groups.push(currentGroup);
+        hasRuleInCurrentGroup = false;
+      }
+      currentGroup.userAgents.push(userAgent);
+      continue;
+    }
+    if (parsed.key === "allow" || parsed.key === "disallow") {
+      if (!currentGroup) {
+        continue;
+      }
+      if (!parsed.value) {
+        continue;
+      }
+      currentGroup.rules.push({ directive: parsed.key, path: parsed.value });
+      hasRuleInCurrentGroup = true;
+      continue;
+    }
+    if (parsed.key === "sitemap") {
+      if (parsed.value) {
+        sitemaps.push(parsed.value);
+      }
+    }
+  }
+  return { groups, sitemaps };
+}
+function escapeRegex(value) {
+  return value.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+}
+function getMatchLength(targetPath, rulePath) {
+  if (!rulePath) {
+    return 0;
+  }
+  if (!rulePath.includes("*") && !rulePath.includes("$")) {
+    return targetPath.startsWith(rulePath) ? rulePath.length : -1;
+  }
+  const endsWithAnchor = rulePath.endsWith("$");
+  const patternBody = endsWithAnchor ? rulePath.slice(0, -1) : rulePath;
+  const escaped = escapeRegex(patternBody).replace(/\\\*/g, ".*");
+  const pattern = endsWithAnchor ? `^${escaped}$` : `^${escaped}`;
+  const regex = new RegExp(pattern);
+  const match = targetPath.match(regex);
+  if (!match || !match[0]) {
+    return -1;
+  }
+  return match[0].length;
+}
+function getDecisionForPath(path, rules) {
+  let bestDecision = "none";
+  let bestLength = -1;
+  for (const rule of rules) {
+    const matchLength = getMatchLength(path, rule.path);
+    if (matchLength < 0) {
+      continue;
+    }
+    if (matchLength > bestLength) {
+      bestLength = matchLength;
+      bestDecision = rule.directive;
+      continue;
+    }
+    if (matchLength === bestLength && rule.directive === "allow") {
+      bestDecision = "allow";
+    }
+  }
+  return {
+    decision: bestDecision,
+    matchedLength: Math.max(bestLength, 0)
+  };
+}
+function pathProbeFromRule(rulePath) {
+  const withoutAnchor = rulePath.endsWith("$") ? rulePath.slice(0, -1) : rulePath;
+  const withWildcardExpanded = withoutAnchor.replace(/\*/g, "sample");
+  if (!withWildcardExpanded.startsWith("/")) {
+    return `/${withWildcardExpanded}`;
+  }
+  return withWildcardExpanded || "/";
+}
+function classifyStatus(rules) {
+  if (rules.length === 0) {
+    return "allowed";
+  }
+  const hasDisallow = rules.some((rule) => rule.directive === "disallow");
+  if (!hasDisallow) {
+    return "allowed";
+  }
+  const rootDecision = getDecisionForPath("/", rules).decision;
+  if (rootDecision === "disallow") {
+    const hasAllowedIsland = rules.some((rule) => {
+      if (rule.directive !== "allow") {
+        return false;
+      }
+      const probe = pathProbeFromRule(rule.path);
+      return getDecisionForPath(probe, rules).decision === "allow";
+    });
+    return hasAllowedIsland ? "partially_blocked" : "blocked";
+  }
+  const blocksAnyPath = rules.some((rule) => {
+    if (rule.directive !== "disallow") {
+      return false;
+    }
+    const probe = pathProbeFromRule(rule.path);
+    return getDecisionForPath(probe, rules).decision === "disallow";
+  });
+  return blocksAnyPath ? "partially_blocked" : "allowed";
+}
+function summarize(results) {
+  const summary = {
+    totalBots: results.length,
+    allowed: 0,
+    blocked: 0,
+    partiallyBlocked: 0,
+    notMentioned: 0
+  };
+  for (const result of results) {
+    if (result.status === "allowed") {
+      summary.allowed += 1;
+    } else if (result.status === "blocked") {
+      summary.blocked += 1;
+    } else if (result.status === "partially_blocked") {
+      summary.partiallyBlocked += 1;
+    } else {
+      summary.notMentioned += 1;
+    }
+  }
+  return summary;
+}
+function toRuleLines(rules) {
+  const seen = /* @__PURE__ */ new Set();
+  const lines = [];
+  for (const rule of rules) {
+    const line = `${rule.directive === "allow" ? "Allow" : "Disallow"}: ${rule.path}`;
+    if (!seen.has(line)) {
+      seen.add(line);
+      lines.push(line);
+    }
+  }
+  return lines;
+}
+function getApplicableRules(parsed, botUserAgent) {
+  const target = botUserAgent.toLowerCase();
+  const specificGroups = parsed.groups.filter(
+    (group) => group.userAgents.some((agent) => agent === target)
+  );
+  if (specificGroups.length > 0) {
+    return {
+      source: "specific",
+      rules: specificGroups.flatMap((group) => group.rules)
+    };
+  }
+  const wildcardGroups = parsed.groups.filter(
+    (group) => group.userAgents.some((agent) => agent === "*")
+  );
+  if (wildcardGroups.length > 0) {
+    return {
+      source: "wildcard",
+      rules: wildcardGroups.flatMap((group) => group.rules)
+    };
+  }
+  return { source: "none", rules: [] };
+}
+function evaluateBotAccess(bot, parsed) {
+  const applicable = getApplicableRules(parsed, bot.userAgent);
+  if (applicable.source === "none") {
+    return {
+      bot,
+      status: "not_mentioned",
+      rules: []
+    };
+  }
+  const status = classifyStatus(applicable.rules);
+  return {
+    bot,
+    status,
+    rules: toRuleLines(applicable.rules)
+  };
+}
+function buildImplicitAllowAnalysis(robotsUrl, warning, bots) {
+  const botResults = bots.map((bot) => ({
+    bot,
+    status: "not_mentioned",
+    rules: []
+  }));
+  return {
+    url: robotsUrl,
+    found: false,
+    rawContent: "",
+    botResults,
+    summary: summarize(botResults),
+    sitemaps: [],
+    warnings: [warning]
+  };
+}
+async function analyzeRobots(siteUrl, options) {
+  const bots = options?.bots ?? aiBots;
+  const timeoutMs = options?.timeoutMs ?? 5e3;
+  const maxRedirects = options?.maxRedirects ?? 5;
+  const robotsUrl = new URL("/robots.txt", siteUrl).toString();
+  try {
+    const { response } = await fetchWithRedirects(robotsUrl, {
+      fetchImpl: options?.fetchImpl,
+      timeoutMs,
+      maxRedirects
+    });
+    if (response.status === 404) {
+      return buildImplicitAllowAnalysis(
+        robotsUrl,
+        "No robots.txt found (404). AI bots are implicitly allowed.",
+        bots
+      );
+    }
+    if (!response.ok) {
+      return buildImplicitAllowAnalysis(
+        robotsUrl,
+        `Could not read robots.txt (${response.status}). AI bots are treated as implicitly allowed.`,
+        bots
+      );
+    }
+    const rawContent = await response.text();
+    const parsed = parseRobotsTxt(rawContent);
+    const botResults = bots.map((bot) => evaluateBotAccess(bot, parsed));
+    return {
+      url: robotsUrl,
+      found: true,
+      rawContent,
+      botResults,
+      summary: summarize(botResults),
+      sitemaps: parsed.sitemaps,
+      warnings: []
+    };
+  } catch (error) {
+    return buildImplicitAllowAnalysis(
+      robotsUrl,
+      `Failed to fetch robots.txt: ${error instanceof Error ? error.message : "Unknown error"}`,
+      bots
+    );
+  }
+}
+
+// src/scanner/page.ts
+function headersToObject(headers) {
+  const output = {};
+  headers.forEach((value, key) => {
+    output[key.toLowerCase()] = value;
+  });
+  return output;
+}
+async function fetchPage(url, options) {
+  const timeoutMs = options?.timeoutMs ?? 8e3;
+  const maxRedirects = options?.maxRedirects ?? 5;
+  const start = Date.now();
+  try {
+    const { response, finalUrl } = await fetchWithRedirects(url, {
+      fetchImpl: options?.fetchImpl,
+      timeoutMs,
+      maxRedirects
+    });
+    const html = await response.text();
+    return {
+      requestedUrl: url,
+      finalUrl,
+      statusCode: response.status,
+      ok: response.ok,
+      html,
+      headers: headersToObject(response.headers),
+      loadTimeMs: Date.now() - start,
+      error: response.ok ? void 0 : `HTTP ${response.status}`
+    };
+  } catch (error) {
+    return {
+      requestedUrl: url,
+      finalUrl: url,
+      statusCode: null,
+      ok: false,
+      html: "",
+      headers: {},
+      loadTimeMs: Date.now() - start,
+      error: error instanceof Error ? error.message : "Unknown fetch error"
+    };
+  }
+}
+
+// src/index.ts
+var SCHEMA_VERSION = "1.0.0";
+var MONITOR_URL = "https://www.summalytics.ai";
+function normalizeUrl(input) {
+  const trimmed = input.trim();
+  if (!trimmed) {
+    throw new Error("URL is empty.");
+  }
+  const withScheme = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+  const parsed = new URL(withScheme);
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error("Only http:// and https:// URLs are supported.");
+  }
+  return parsed.toString();
+}
+function notMentionedWarningRecommendation(count) {
+  if (count <= 0) {
+    return null;
+  }
+  return {
+    priority: "low",
+    category: "AI Accessibility",
+    message: `${count} AI bot(s) are not explicitly mentioned in robots.txt. Add explicit directives for policy clarity.`,
+    impact: "No score impact",
+    checkId: "ai.bots_explicit_policy"
+  };
+}
+async function geoCheck(url, options) {
+  const startedAt = Date.now();
+  const scannedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const warnings = [];
+  const errors = [];
+  let targetUrl;
+  try {
+    targetUrl = normalizeUrl(url);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Invalid URL";
+    return {
+      schemaVersion: SCHEMA_VERSION,
+      targetUrl: url,
+      scannedAt,
+      durationMs: Date.now() - startedAt,
+      robots: null,
+      geoScore: null,
+      recommendations: [],
+      monitor: MONITOR_URL,
+      warnings,
+      errors: [message],
+      success: false
+    };
+  }
+  const shouldFetchPage = !options?.robotsOnly;
+  const shouldFetchRobots = true;
+  const [robots, page] = await Promise.all([
+    shouldFetchRobots ? analyzeRobots(targetUrl, {
+      fetchImpl: options?.fetchImpl,
+      timeoutMs: 5e3,
+      maxRedirects: 5,
+      bots: aiBots
+    }) : Promise.resolve(null),
+    shouldFetchPage ? fetchPage(targetUrl, {
+      fetchImpl: options?.fetchImpl,
+      timeoutMs: 8e3,
+      maxRedirects: 5
+    }) : Promise.resolve(null)
+  ]);
+  if (robots?.warnings.length) {
+    warnings.push(...robots.warnings);
+  }
+  if (page?.error) {
+    warnings.push(`Page fetch warning: ${page.error}`);
+  }
+  let geoScore = null;
+  if (shouldFetchPage) {
+    if (page && page.ok && page.html) {
+      geoScore = analyzeGeoScore({
+        html: page.html,
+        finalUrl: page.finalUrl,
+        loadTimeMs: page.loadTimeMs,
+        robots: robots ?? {
+          url: `${targetUrl.replace(/\/$/, "")}/robots.txt`,
+          found: false,
+          rawContent: "",
+          botResults: [],
+          summary: {
+            totalBots: 0,
+            allowed: 0,
+            blocked: 0,
+            partiallyBlocked: 0,
+            notMentioned: 0
+          },
+          sitemaps: [],
+          warnings: []
+        }
+      });
+    } else {
+      errors.push("Could not fetch page HTML for GEO analysis.");
+    }
+  }
+  const recommendations = geoScore ? [...geoScore.recommendations] : [];
+  if (!geoScore && robots) {
+    const warningRec = notMentionedWarningRecommendation(robots.summary.notMentioned);
+    if (warningRec) {
+      recommendations.push(warningRec);
+    }
+  }
+  const result = {
+    schemaVersion: SCHEMA_VERSION,
+    targetUrl,
+    scannedAt,
+    durationMs: Date.now() - startedAt,
+    robots: options?.geoOnly ? null : robots,
+    geoScore: options?.robotsOnly ? null : geoScore,
+    recommendations,
+    monitor: MONITOR_URL,
+    warnings,
+    errors,
+    success: errors.length === 0 || !!robots
+  };
+  return result;
+}
+async function mapLimit(items, concurrency, worker) {
+  const output = new Array(items.length);
+  let nextIndex = 0;
+  async function runner() {
+    while (true) {
+      const current = nextIndex;
+      nextIndex += 1;
+      if (current >= items.length) {
+        return;
+      }
+      output[current] = await worker(items[current], current);
+    }
+  }
+  const safeConcurrency = Math.max(1, Math.min(concurrency, items.length || 1));
+  await Promise.all(Array.from({ length: safeConcurrency }, () => runner()));
+  return output;
+}
+async function geoCheckMany(urls, options) {
+  const concurrency = options?.concurrency ?? 3;
+  return mapLimit(urls, concurrency, (url) => geoCheck(url, options));
+}
+
+// src/reporters/json.ts
+function serializeResult(result) {
+  return {
+    schemaVersion: result.schemaVersion,
+    targetUrl: result.targetUrl,
+    scannedAt: result.scannedAt,
+    durationMs: result.durationMs,
+    robots: result.robots,
+    geoScore: result.geoScore,
+    recommendations: result.recommendations,
+    monitor: result.monitor,
+    warnings: result.warnings,
+    errors: result.errors,
+    success: result.success
+  };
+}
+function formatJsonOutput(result) {
+  const payload = Array.isArray(result) ? result.map((item) => serializeResult(item)) : serializeResult(result);
+  return JSON.stringify(payload, null, 2);
+}
+
+// src/reporters/terminal.ts
+import chalk from "chalk";
+import Table from "cli-table3";
+var PRIORITY_ICON = {
+  high: "\u{1F534}",
+  medium: "\u{1F7E1}",
+  low: "\u{1F7E2}"
+};
+function statusBadge(status) {
+  if (status === "allowed") {
+    return `${chalk.green("\u2705")} Allowed`;
+  }
+  if (status === "blocked") {
+    return `${chalk.red("\u274C")} Blocked`;
+  }
+  if (status === "partially_blocked") {
+    return `${chalk.yellow("\u26A0\uFE0F")} Partially blocked`;
+  }
+  return `${chalk.yellow("\u26A0\uFE0F")} Not mentioned (implicitly allowed)`;
+}
+function bar(score, max, width = 12) {
+  const ratio = max === 0 ? 0 : score / max;
+  const filled = Math.round(ratio * width);
+  return `${"\u2588".repeat(filled)}${"\u2591".repeat(Math.max(0, width - filled))}`;
+}
+function headerBlock() {
+  const lines = [
+    "\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510",
+    "\u2502                  geo-check v1.0.0                  \u2502",
+    "\u2502               AI Visibility Scanner                \u2502",
+    "\u2502            https://www.summalytics.ai             \u2502",
+    "\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"
+  ];
+  return chalk.cyan(lines.join("\n"));
+}
+function renderBots(results) {
+  const table = new Table({
+    head: ["Bot", "Company", "Status"],
+    colWidths: [24, 16, 34],
+    wordWrap: true
+  });
+  for (const result of results) {
+    table.push([result.bot.name, result.bot.company, statusBadge(result.status)]);
+  }
+  return table.toString();
+}
+function renderRecommendations(recommendations, verbose) {
+  const selected = verbose ? recommendations : recommendations.slice(0, 5);
+  if (selected.length === 0) {
+    return `${chalk.green("\u2705")} No recommendations. GEO profile looks strong.`;
+  }
+  return selected.map((recommendation) => {
+    const icon = PRIORITY_ICON[recommendation.priority];
+    return `  ${icon} ${recommendation.priority.toUpperCase()}: ${recommendation.message} (${recommendation.impact})`;
+  }).join("\n");
+}
+function partialBlockExplanation(results) {
+  const partialResults = results.filter((result) => result.status === "partially_blocked");
+  if (partialResults.length === 0) {
+    return [];
+  }
+  const ruleCounts = /* @__PURE__ */ new Map();
+  for (const result of partialResults) {
+    for (const rule of result.rules) {
+      if (!rule.startsWith("Disallow:")) {
+        continue;
+      }
+      ruleCounts.set(rule, (ruleCounts.get(rule) ?? 0) + 1);
+    }
+  }
+  const topRules = [...ruleCounts.entries()].sort((left, right) => right[1] - left[1]).slice(0, 3).map(([rule, count]) => `${rule} (${count})`);
+  const lines = [
+    `${chalk.yellow("\u2139\uFE0F")} Partially blocked means bots can crawl some paths but are blocked on others by robots.txt rules.`
+  ];
+  if (topRules.length > 0) {
+    lines.push(`   Top blocking rules: ${topRules.join(" \xB7 ")}`);
+  }
+  return lines;
+}
+function renderSingleResult(result, options) {
+  const lines = [];
+  lines.push(headerBlock());
+  lines.push("");
+  lines.push(`Scanning ${chalk.bold(result.targetUrl)} ...`);
+  if (!result.success) {
+    lines.push(chalk.red("Scan failed."));
+    if (result.errors.length > 0) {
+      for (const error of result.errors) {
+        lines.push(`  ${chalk.red("\u274C")} ${error}`);
+      }
+    }
+    return lines.join("\n");
+  }
+  if (result.geoScore) {
+    lines.push("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    lines.push(
+      `${chalk.bold("\u{1F4CA} GEO READINESS SCORE")}: ${chalk.bold(`${result.geoScore.total}/100`)} (${result.geoScore.grade})`
+    );
+    lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    const { categories } = result.geoScore;
+    lines.push(
+      `  Structured Data     ${bar(categories.structuredData.score, categories.structuredData.maxScore)}  ${categories.structuredData.score}/${categories.structuredData.maxScore}`
+    );
+    lines.push(
+      `  Content Structure   ${bar(categories.contentStructure.score, categories.contentStructure.maxScore)}  ${categories.contentStructure.score}/${categories.contentStructure.maxScore}`
+    );
+    lines.push(
+      `  Authority Signals   ${bar(categories.authoritySignals.score, categories.authoritySignals.maxScore)}  ${categories.authoritySignals.score}/${categories.authoritySignals.maxScore}`
+    );
+    lines.push(
+      `  AI Accessibility    ${bar(categories.aiAccessibility.score, categories.aiAccessibility.maxScore)}  ${categories.aiAccessibility.score}/${categories.aiAccessibility.maxScore}`
+    );
+  }
+  if (result.robots) {
+    lines.push("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    lines.push(chalk.bold("\u{1F916} AI BOT ACCESS"));
+    lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+    lines.push(renderBots(result.robots.botResults));
+    lines.push(
+      `Summary: ${result.robots.summary.allowed} allowed \xB7 ${result.robots.summary.blocked} blocked \xB7 ${result.robots.summary.partiallyBlocked} partial \xB7 ${result.robots.summary.notMentioned} not mentioned`
+    );
+    lines.push(...partialBlockExplanation(result.robots.botResults));
+  }
+  lines.push("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(chalk.bold("\u{1F4A1} TOP RECOMMENDATIONS"));
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push(renderRecommendations(result.recommendations, options.verbose));
+  if (result.warnings.length > 0) {
+    lines.push("\nWarnings:");
+    for (const warning of result.warnings) {
+      lines.push(`  ${chalk.yellow("\u26A0\uFE0F")} ${warning}`);
+    }
+  }
+  if (options.verbose && result.geoScore) {
+    lines.push("\nVerbose checks:");
+    for (const [categoryName, category] of Object.entries(result.geoScore.categories)) {
+      lines.push(`  ${chalk.bold(categoryName)}: ${category.score}/${category.maxScore}`);
+      for (const check2 of category.checks) {
+        const marker = check2.passed ? chalk.green("\u2705") : chalk.red("\u274C");
+        lines.push(`    ${marker} ${check2.name} (${check2.points}/${check2.maxPoints}) - ${check2.detail}`);
+      }
+    }
+  }
+  lines.push("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  lines.push("For ongoing monitoring and AI traffic analytics: https://www.summalytics.ai");
+  lines.push("\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501");
+  return lines.join("\n");
+}
+function renderTerminalResults(results, options) {
+  return results.map((result) => renderSingleResult(result, options)).join("\n\n");
+}
+
+// src/cli.ts
+var defaultIO = {
+  stdout: (message) => console.log(message),
+  stderr: (message) => console.error(message)
+};
+async function runCli(argv = process.argv, io = defaultIO) {
+  const program = new Command();
+  program.name("geo-check").description("AI Visibility Scanner \u2014 robots.txt AI bot access + GEO readiness score").argument("[urls...]", "Target URLs to scan").option("--json", "Output machine-readable JSON").option("--robots-only", "Only run robots.txt checks").option("--geo-only", "Only output GEO score").option("--verbose", "Show all check details").showHelpAfterError();
+  program.exitOverride();
+  try {
+    program.parse(argv);
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      if (error.code !== "commander.helpDisplayed") {
+        io.stderr(error.message);
+      }
+      return 2;
+    }
+    throw error;
+  }
+  const opts = program.opts();
+  const urls = program.args;
+  if (urls.length === 0) {
+    io.stderr("Please provide at least one URL. Example: npx geo-check https://example.com");
+    return 2;
+  }
+  if (opts.robotsOnly && opts.geoOnly) {
+    io.stderr("--robots-only and --geo-only cannot be used together.");
+    return 2;
+  }
+  const results = await geoCheckMany(urls, {
+    robotsOnly: opts.robotsOnly,
+    geoOnly: opts.geoOnly,
+    verbose: opts.verbose,
+    concurrency: 3
+  });
+  if (opts.json) {
+    io.stdout(formatJsonOutput(results.length === 1 ? results[0] : results));
+  } else {
+    io.stdout(renderTerminalResults(results, { verbose: Boolean(opts.verbose) }));
+  }
+  return results.some((result) => result.success) ? 0 : 1;
+}
+var directInvocation = process.argv[1] ? import.meta.url === pathToFileURL(process.argv[1]).href : false;
+if (directInvocation) {
+  runCli().then((code) => {
+    process.exit(code);
+  });
+}
+export {
+  runCli
+};
+//# sourceMappingURL=cli.js.map