@agentimization/core 0.1.1 → 0.1.3

package/dist/index.js

@@ -769,11 +769,11 @@ var extractMetaTags = (html) => {
   const metaRegex = /<meta[^>]+(?:name|property)=["']([^"']+)["'][^>]+content=["']([^"']+)["']/gi;
   let match;
   while ((match = metaRegex.exec(html)) !== null) {
-    meta[match[1]] = match[2];
+    meta[match[1].toLowerCase()] = match[2];
   }
   const metaRegex2 = /<meta[^>]+content=["']([^"']+)["'][^>]+(?:name|property)=["']([^"']+)["']/gi;
   while ((match = metaRegex2.exec(html)) !== null) {
-    meta[match[2]] = match[1];
+    meta[match[2].toLowerCase()] = match[1];
   }
   return meta;
 };
@@ -789,6 +789,24 @@ var extractJsonLd = (html) => {
   }
   return results;
 };
+var readAttr = (attrs, name) => {
+  const re = new RegExp(`\\b${name}=(?:"([^"]*)"|'([^']*)')`, "i");
+  const m = attrs.match(re);
+  if (!m) return void 0;
+  return m[1] ?? m[2];
+};
+var extractImages = (html) => {
+  const images = [];
+  const imgRegex = /<img\b([^>]*)>/gi;
+  let match;
+  while ((match = imgRegex.exec(html)) !== null) {
+    const attrs = match[1];
+    const src = readAttr(attrs, "src");
+    if (src === void 0) continue;
+    images.push({ src, alt: readAttr(attrs, "alt") });
+  }
+  return images;
+};
 var extractHeadings = (html) => {
   const headings = [];
   const regex = /<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi;
@@ -902,6 +920,53 @@ var renderingStrategy = {
     };
   }
 };
+var substantialTextContent = {
+  id: "substantial-text-content",
+  name: "Substantial Text Content",
+  category: "page-size",
+  description: "Checks for at least 100 words of readable body text",
+  weight: 0.8,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    if (pages.length === 0) {
+      return {
+        id: "substantial-text-content",
+        name: "Substantial Text Content",
+        category: "page-size",
+        status: "skip",
+        message: "No pages sampled"
+      };
+    }
+    let withSubstantialContent = 0;
+    let totalWords = 0;
+    for (const page of pages) {
+      const text = stripHtml(page.html);
+      const words = text.split(/\s+/).filter((w) => w.length > 0).length;
+      totalWords += words;
+      if (words >= 100) withSubstantialContent++;
+    }
+    const avgWords = Math.round(totalWords / pages.length);
+    if (withSubstantialContent === pages.length) {
+      return {
+        id: "substantial-text-content",
+        name: "Substantial Text Content",
+        category: "page-size",
+        status: "pass",
+        message: `All ${pages.length} pages have \u2265100 words of body text (avg ${avgWords})`,
+        metadata: { withSubstantialContent, avgWords }
+      };
+    }
+    return {
+      id: "substantial-text-content",
+      name: "Substantial Text Content",
+      category: "page-size",
+      status: withSubstantialContent > 0 ? "warn" : "fail",
+      message: `${withSubstantialContent}/${pages.length} pages have \u2265100 words of body text (avg ${avgWords})`,
+      suggestion: "Generative engines can't cite pages that are mostly images or short copy. Add at least 100 words of substantive text content per page.",
+      metadata: { withSubstantialContent, avgWords }
+    };
+  }
+};
 var pageSizeHtml = {
   id: "page-size-html",
   name: "Page Size (HTML)",
@@ -1036,6 +1101,7 @@ var contentStartPosition = {
 };
 var pageSizeChecks = [
   renderingStrategy,
+  substantialTextContent,
   pageSizeHtml,
   pageSizeMarkdown,
   contentStartPosition
@@ -1209,13 +1275,105 @@ var tabbedContentSerialization = {
     };
   }
 };
+var imageAltText = {
+  id: "image-alt-text",
+  name: "Image Alt Text Coverage",
+  category: "content-structure",
+  description: "Checks that at least 50% of images have descriptive alt text",
+  weight: 0.5,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    if (pages.length === 0) {
+      return {
+        id: "image-alt-text",
+        name: "Image Alt Text Coverage",
+        category: "content-structure",
+        status: "skip",
+        message: "No pages sampled"
+      };
+    }
+    const allImages = pages.flatMap((p) => extractImages(p.html));
+    const contentImages = allImages.filter((img) => img.alt === void 0 || img.alt.trim().length > 0);
+    const decorativeImages = allImages.length - contentImages.length;
+    const withAlt = contentImages.filter((img) => img.alt !== void 0 && img.alt.trim().length > 0).length;
+    if (allImages.length === 0) {
+      return {
+        id: "image-alt-text",
+        name: "Image Alt Text Coverage",
+        category: "content-structure",
+        status: "info",
+        message: `No images found across ${pages.length} sampled pages`
+      };
+    }
+    if (contentImages.length === 0) {
+      return {
+        id: "image-alt-text",
+        name: "Image Alt Text Coverage",
+        category: "content-structure",
+        status: "info",
+        message: `All ${allImages.length} sampled images are decorative (alt="")`,
+        metadata: { decorativeImages, totalImages: allImages.length }
+      };
+    }
+    const ratio = withAlt / contentImages.length;
+    const pct = Math.round(ratio * 100);
+    const summary = `${withAlt}/${contentImages.length} content images have descriptive alt text (${pct}%)${decorativeImages > 0 ? `; ${decorativeImages} decorative skipped` : ""}`;
+    if (ratio >= 0.5) {
+      return {
+        id: "image-alt-text",
+        name: "Image Alt Text Coverage",
+        category: "content-structure",
+        status: "pass",
+        message: summary,
+        metadata: { withAlt, contentImages: contentImages.length, decorativeImages, pct }
+      };
+    }
+    return {
+      id: "image-alt-text",
+      name: "Image Alt Text Coverage",
+      category: "content-structure",
+      status: ratio >= 0.25 ? "warn" : "fail",
+      message: summary,
+      suggestion: `Add descriptive alt text to at least 50% of content images. AI agents and screen readers rely on alt text to understand visual content. Mark purely decorative images with alt="" so they don't dilute the ratio.`,
+      metadata: { withAlt, contentImages: contentImages.length, decorativeImages, pct }
+    };
+  }
+};
 var contentStructureChecks = [
   markdownCodeFenceValidity,
   sectionHeaderQuality,
-  tabbedContentSerialization
+  tabbedContentSerialization,
+  imageAltText
 ];
 
 // src/checks/url-stability.ts
+var httpsEnabled = {
+  id: "https-enabled",
+  name: "HTTPS Enabled",
+  category: "url-stability",
+  description: "Checks if the site is served over HTTPS",
+  weight: 0.7,
+  requiresNetwork: true,
+  run: async (ctx) => {
+    if (ctx.baseUrl.protocol === "https:") {
+      return {
+        id: "https-enabled",
+        name: "HTTPS Enabled",
+        category: "url-stability",
+        status: "pass",
+        message: "Site is served over HTTPS"
+      };
+    }
+    return {
+      id: "https-enabled",
+      name: "HTTPS Enabled",
+      category: "url-stability",
+      status: "fail",
+      message: `Site is served over ${ctx.baseUrl.protocol.replace(":", "")} \u2014 AI crawlers de-prioritize non-HTTPS sources`,
+      suggestion: "Serve your site over HTTPS. AI crawlers like GPTBot, ClaudeBot, and PerplexityBot strongly prefer HTTPS and may skip plain HTTP entirely."
+    };
+  }
+};
 var httpStatusCodes = {
   id: "http-status-codes",
   name: "HTTP Status Codes",
@@ -1327,6 +1485,7 @@ var cacheHeaderHygiene = {
   }
 };
 var urlStabilityChecks = [
+  httpsEnabled,
   httpStatusCodes,
   redirectBehavior,
   cacheHeaderHygiene
@@ -1736,6 +1895,185 @@ var faqSchema = {
     };
   }
 };
+var metaDescription = {
+  id: "meta-description",
+  name: "Meta Description",
+  category: "geo-signals",
+  description: "Checks for a meta description between 50 and 160 characters",
+  weight: 0.5,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    if (pages.length === 0) {
+      return {
+        id: "meta-description",
+        name: "Meta Description",
+        category: "geo-signals",
+        status: "skip",
+        message: "No pages sampled"
+      };
+    }
+    let withGoodDescription = 0;
+    let missing = 0;
+    let tooShort = 0;
+    let tooLong = 0;
+    for (const page of pages) {
+      const meta = extractMetaTags(page.html);
+      const description = meta["description"]?.trim();
+      if (!description) {
+        missing++;
+        continue;
+      }
+      const len = description.length;
+      if (len >= 50 && len <= 160) withGoodDescription++;
+      else if (len < 50) tooShort++;
+      else tooLong++;
+    }
+    if (withGoodDescription === pages.length) {
+      return {
+        id: "meta-description",
+        name: "Meta Description",
+        category: "geo-signals",
+        status: "pass",
+        message: `All ${pages.length} pages have a meta description between 50\u2013160 characters`,
+        metadata: { withGoodDescription }
+      };
+    }
+    if (missing === pages.length) {
+      return {
+        id: "meta-description",
+        name: "Meta Description",
+        category: "geo-signals",
+        status: "fail",
+        message: "No meta description found on any sampled page",
+        suggestion: 'Add a <meta name="description"> between 50 and 160 characters to every page. Generative engines quote meta descriptions when summarizing your content.'
+      };
+    }
+    const detail = [
+      missing > 0 ? `${missing} missing` : null,
+      tooShort > 0 ? `${tooShort} too short` : null,
+      tooLong > 0 ? `${tooLong} too long` : null
+    ].filter(Boolean).join(" \xB7 ");
+    return {
+      id: "meta-description",
+      name: "Meta Description",
+      category: "geo-signals",
+      status: missing >= pages.length / 2 ? "fail" : "warn",
+      message: `${withGoodDescription}/${pages.length} pages have meta descriptions in the 50\u2013160 char range${detail ? ` \xB7 ${detail}` : ""}`,
+      suggestion: missing > 0 ? 'Add a <meta name="description"> between 50 and 160 characters to every page. Some pages are missing it entirely.' : "Aim for 50\u2013160 characters. Shorter descriptions lack context for AI; longer ones get truncated.",
+      metadata: { withGoodDescription, missing, tooShort, tooLong }
+    };
+  }
+};
+var openGraphTags = {
+  id: "open-graph-tags",
+  name: "Open Graph Tags",
+  category: "geo-signals",
+  description: "Checks for og:title, og:description, og:image, and og:url",
+  weight: 0.5,
+  run: async (ctx) => {
+    const pages = ctx.sampledPages.slice(0, 10);
+    if (pages.length === 0) {
+      return {
+        id: "open-graph-tags",
+        name: "Open Graph Tags",
+        category: "geo-signals",
+        status: "skip",
+        message: "No pages sampled"
+      };
+    }
+    const required = ["og:title", "og:description", "og:image", "og:url"];
+    let fullCoverage = 0;
+    let partialCoverage = 0;
+    const missingCounts = { "og:title": 0, "og:description": 0, "og:image": 0, "og:url": 0 };
+    for (const page of pages) {
+      const meta = extractMetaTags(page.html);
+      const missing = required.filter((tag) => !meta[tag]);
+      for (const tag of missing) missingCounts[tag] = (missingCounts[tag] ?? 0) + 1;
+      if (missing.length === 0) fullCoverage++;
+      else if (missing.length < required.length) partialCoverage++;
+    }
+    if (fullCoverage === pages.length) {
+      return {
+        id: "open-graph-tags",
+        name: "Open Graph Tags",
+        category: "geo-signals",
+        status: "pass",
+        message: `All ${pages.length} pages have complete Open Graph tags`
+      };
+    }
+    const mostMissing = Object.entries(missingCounts).filter(([, n]) => n > 0).sort(([, a], [, b]) => b - a).map(([tag]) => tag);
+    const noneCovered = pages.length - fullCoverage - partialCoverage;
+    return {
+      id: "open-graph-tags",
+      name: "Open Graph Tags",
+      category: "geo-signals",
+      status: fullCoverage + partialCoverage === 0 ? "fail" : "warn",
+      message: `${fullCoverage}/${pages.length} pages have complete Open Graph tags${partialCoverage > 0 ? ` \xB7 ${partialCoverage} partial` : ""}${noneCovered > 0 ? ` \xB7 ${noneCovered} with none` : ""}${mostMissing.length > 0 ? ` \xB7 most often missing: ${mostMissing.slice(0, 2).join(", ")}` : ""}`,
+      suggestion: "Add og:title, og:description, og:image, and og:url to every page. AI engines and link previews use these to render rich citations of your content.",
+      metadata: { fullCoverage, partialCoverage, noneCovered, missingCounts }
+    };
+  }
+};
+var externalCitations = {
+  id: "external-citations",
+  name: "External Citations",
+  category: "geo-signals",
+  description: "Checks for at least 2 outbound links to external sources per page",
+  weight: 0.5,
+  run: async (ctx) => {
+    if (ctx.mode === "local") {
+      return {
+        id: "external-citations",
+        name: "External Citations",
+        category: "geo-signals",
+        status: "info",
+        message: "External link detection requires a live origin to compare against"
+      };
+    }
+    const pages = ctx.sampledPages.slice(0, 10);
+    if (pages.length === 0) {
+      return {
+        id: "external-citations",
+        name: "External Citations",
+        category: "geo-signals",
+        status: "skip",
+        message: "No pages sampled"
+      };
+    }
+    const origin = ctx.baseUrl.origin;
+    let pagesWithCitations = 0;
+    let totalExternal = 0;
+    for (const page of pages) {
+      const links = extractLinks(page.html, origin);
+      const external = links.filter((l) => {
+        const u = new URL(l);
+        return u.protocol.startsWith("http") && u.origin !== origin;
+      });
+      totalExternal += external.length;
+      if (external.length >= 2) pagesWithCitations++;
+    }
+    const avgExternal = Math.round(totalExternal / pages.length);
+    if (pagesWithCitations >= pages.length * 0.7) {
+      return {
+        id: "external-citations",
+        name: "External Citations",
+        category: "geo-signals",
+        status: "pass",
+        message: `${pagesWithCitations}/${pages.length} pages have \u22652 outbound links (avg ${avgExternal}/page)`,
+        metadata: { pagesWithCitations, avgExternal }
+      };
+    }
+    return {
+      id: "external-citations",
+      name: "External Citations",
+      category: "geo-signals",
+      status: pagesWithCitations > 0 ? "warn" : "fail",
+      message: `Only ${pagesWithCitations}/${pages.length} pages have \u22652 outbound links (avg ${avgExternal}/page)`,
+      suggestion: "Add at least 2 outbound links to authoritative external sources per page. Citing sources signals credibility to generative engines, which weigh outbound links when deciding what to cite.",
+      metadata: { pagesWithCitations, avgExternal }
+    };
+  }
+};
 var canonicalUrlConsistency = {
   id: "canonical-url-consistency",
   name: "Canonical URL Consistency",
@@ -1806,6 +2144,9 @@ var geoSignalChecks = [
   contentFreshness,
   eeatSignals,
   faqSchema,
+  metaDescription,
+  openGraphTags,
+  externalCitations,
   canonicalUrlConsistency
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentimization/core",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "GEO audit engine. Check if your website is agent-ready and generative-engine optimized.",
   "keywords": [
     "geo",