aeo-ready 1.3.1 → 1.4.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.4.0
+
+- Add Vercel Agent Readability benchmark (`@vercel/agent-readability`)
+- Add AgentGrade benchmark (`agentgrade-cli`)
+- Scan now runs 5 benchmarks in parallel: agentic-seo, Cloudflare, Fern, Vercel, AgentGrade
+
+## 1.3.2
+
+- Fix broken `afdocs` fix command — was calling `npx afdocs <url>` instead of `npx afdocs check <url>`
+- Fix shell injection in `promptFix` — switched `execSync` to `execFileSync`
+- Add test suite (`node --test`)
+- Add GitHub Actions CI
+
 ## 1.3.1
 
 - Add progress indicator during scan

package/README.md

@@ -17,6 +17,8 @@ Runs every major AEO (Agentic Engine Optimization) benchmark against your site i
 | **agentic-seo** (Addy Osmani) | Discovery, content structure, token economics, capability signaling, UX bridge | 10 |
 | **Cloudflare** (isitagentready.com) | Discoverability, content accessibility, bot access, API/MCP/A2A discovery, commerce | 19 |
 | **Fern** (afdocs) | llms.txt quality, markdown availability, page size, content structure, URL stability, auth | 23 |
+| **Vercel** (Agent Readability Spec) | Agent reachability, discoverability, markdown serving, HTML agent-friendliness | 25 |
+| **AgentGrade** (agentgrade.com) | MCP, payment protocols, identity standards, content negotiation, OpenAPI, infrastructure | 70+ |
 
 ## Usage
 
@@ -41,19 +43,19 @@ With --dir: agentic-seo 92/100 (A)
 ```
   aeo-ready — yoursite.com
 
+  Checking agentic-seo · Cloudflare · Fern · Vercel · AgentGrade...
+
   agentic-seo ·································· 91/100 A
     ✓ Discovery              25/25
     ◑ Content Structure      18/25
     ✓ Token Economics        25/25
     ✓ Capability Signaling   15/15
     ✓ UX Bridge               8/10
-    vs Cloudflare 55 · Supabase 52 · Vercel 48 · Stripe 17
 
   Cloudflare ···································· 4/5 B
     10 passed  2 failed
     ✗ robotsTxtAiRules  No rules for AI bots found
     ✗ contentSignals    No content signals in robots.txt
-    vs Cloudflare 5 · Vercel 4 · Supabase 3 · Stripe 2
 
   Fern ········································ 83/100 B
     9 passed  4 failed
@@ -61,14 +63,26 @@ With --dir: agentic-seo 92/100 (A)
     ✗ content-start-position   2 pages have content past 50%
     ✗ llms-txt-coverage        Covers 67% of sitemap
     ✗ markdown-content-parity  4 pages have content differences
-    vs Stripe 85 · Supabase 78 · Anthropic 72 · Vercel 60
+
+  Vercel ····································· 75/100 B
+    15 passed  5 failed
+    ✗ robots.txt               blocked: ccbot
+    ✗ Agent UA → markdown      returned HTML
+    ✗ .md URL → markdown       status 404
+    ✗ Frontmatter              no frontmatter found
+    ✗ Missing page → markdown  returned 404
+
+  AgentGrade ································ 81/100 B+
+    30 passed  10 failed
+    ✗ llms.txt linked from HTML
+    ✗ Accept: JSON returns JSON
+    ✗ Accept: text returns text
 
   ──────────────────────────────────────────────────
   Overall                                     85/100
 
   Next steps
-    npx agentic-seo init                          scaffold llms.txt, AGENTS.md
-    npx afdocs https://yoursite.com               4 Fern issues
+    npx afdocs check https://yoursite.com         4 Fern issues
     npx skills add katrinalaszlo/agent-serve      make your product agent-ready
 
   Fix now? [y/N]
@@ -96,7 +110,7 @@ npx aeo-ready history                          # show last 10 scans
 import { scan, getHistory } from "aeo-ready";
 
 const result = await scan({ url: "https://yoursite.com", dir: "./public", json: true });
-// result.averageScore, result.benchmarks.agenticSeo, .cloudflare, .fern
+// result.averageScore, result.benchmarks.agenticSeo, .cloudflare, .fern, .vercel, .agentgrade
 
 const history = getHistory(process.cwd());
 // history.scans — array of past scan results

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aeo-ready",
-  "version": "1.3.1",
-  "description": "AEO benchmark aggregator. One scan, every score. Collects agentic-seo, Cloudflare, and Fern in one report.",
+  "version": "1.4.0",
+  "description": "AEO benchmark aggregator. One scan, every score. Collects agentic-seo, Cloudflare, Fern, Vercel, and AgentGrade in one report.",
   "type": "module",
   "bin": {
     "aeo-ready": "./bin/cli.js"
@@ -37,7 +37,6 @@
     "bin/",
     "src/benchmark/",
     "src/history/",
-    "src/utils/",
     "src/index.js",
     "src/scan.js",
     "skills/",

package/src/benchmark/agentgrade.js

@@ -0,0 +1,55 @@
+import { execFileSync } from "child_process";
+
+export async function runAgentgrade(url) {
+  try {
+    const raw = execFileSync("npx", ["agentgrade-cli", url, "--json"], {
+      timeout: 60000,
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+
+    const jsonStart = raw.indexOf("{");
+    if (jsonStart === -1) {
+      return { available: false, reason: "no JSON in output" };
+    }
+    const result = JSON.parse(raw.slice(jsonStart));
+    const scoreObj = result.score || {};
+
+    const categories = {};
+    for (const group of scoreObj.groups || []) {
+      if (!group.applicable) continue;
+      categories[group.key] = {
+        name: group.label,
+        score: group.passed,
+        maxScore: group.total,
+        percentage: group.pct ?? 0,
+      };
+    }
+
+    const checks = [];
+    for (const group of scoreObj.groups || []) {
+      if (!group.applicable) continue;
+      for (const check of group.checks || []) {
+        checks.push({
+          id: check.label,
+          status: check.passed ? "pass" : "fail",
+          message: check.hint || "",
+        });
+      }
+    }
+
+    return {
+      score: scoreObj.pct ?? 0,
+      maxScore: 100,
+      grade: scoreObj.grade || null,
+      categories,
+      checks,
+      available: true,
+    };
+  } catch (err) {
+    console.warn(
+      `Warning: AgentGrade benchmark failed for ${url}: ${err.message}`,
+    );
+    return { available: false, reason: err.message?.slice(0, 100) };
+  }
+}

package/src/benchmark/agentic-seo.js

@@ -1,4 +1,4 @@
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "fs";
 import { tmpdir } from "os";
 import { join, dirname } from "path";
@@ -21,7 +21,8 @@ async function fetchText(url) {
     const res = await fetch(url, { redirect: "follow" });
     if (!res.ok) return null;
     return await res.text();
-  } catch {
+  } catch (err) {
+    console.warn(`Warning: failed to fetch ${url}: ${err.message}`);
     return null;
   }
 }
@@ -102,7 +103,7 @@ export async function runBenchmark(target) {
       scanDir = target || ".";
     }
 
-    const output = execSync(`npx agentic-seo ${scanDir} --json`, {
+    const output = execFileSync("npx", ["agentic-seo", scanDir, "--json"], {
       timeout: 60000,
       encoding: "utf8",
       stdio: ["pipe", "pipe", "pipe"],
@@ -135,7 +136,11 @@ export async function runBenchmark(target) {
     if (tempDir) {
       try {
         rmSync(tempDir, { recursive: true, force: true });
-      } catch {}
+      } catch (cleanupErr) {
+        console.warn(
+          `Warning: failed to clean up temp dir ${tempDir}: ${cleanupErr.message}`,
+        );
+      }
     }
   }
 }

package/src/benchmark/cloudflare.js

@@ -62,6 +62,9 @@ export async function runCloudflare(url) {
       available: true,
     };
   } catch (err) {
+    console.warn(
+      `Warning: Cloudflare benchmark failed for ${url}: ${err.message}`,
+    );
     return { available: false, reason: err.message?.slice(0, 100) };
   }
 }

package/src/benchmark/fern.js

@@ -46,6 +46,7 @@ export async function runFern(url) {
       available: true,
     };
   } catch (err) {
+    console.warn(`Warning: Fern benchmark failed for ${url}: ${err.message}`);
     return { available: false, reason: err.message?.slice(0, 100) };
   }
 }

package/src/benchmark/index.js

@@ -2,6 +2,8 @@ import chalk from "chalk";
 import { runBenchmark as runAgenticSeo } from "./agentic-seo.js";
 import { runCloudflare } from "./cloudflare.js";
 import { runFern } from "./fern.js";
+import { runVercel } from "./vercel.js";
+import { runAgentgrade } from "./agentgrade.js";
 
 const REFERENCE_SCORES = {
   agenticSeo: {
@@ -36,12 +38,16 @@ export async function runAllBenchmarks(target, dir) {
     runAgenticSeo(dir || target),
     isUrl ? runCloudflare(target) : Promise.resolve(null),
     isUrl ? runFern(target) : Promise.resolve(null),
+    isUrl ? runVercel(target) : Promise.resolve(null),
+    isUrl ? runAgentgrade(target) : Promise.resolve(null),
   ]);
 
   return {
     agenticSeo: results[0].status === "fulfilled" ? results[0].value : null,
     cloudflare: results[1].status === "fulfilled" ? results[1].value : null,
     fern: results[2].status === "fulfilled" ? results[2].value : null,
+    vercel: results[3].status === "fulfilled" ? results[3].value : null,
+    agentgrade: results[4].status === "fulfilled" ? results[4].value : null,
   };
 }
 
@@ -60,6 +66,12 @@ export function printBenchmarks(benchmarks) {
   if (benchmarks.fern?.available) {
     printBenchmarkBlock("Fern", "fern", benchmarks.fern);
   }
+  if (benchmarks.vercel?.available) {
+    printBenchmarkBlock("Vercel", "vercel", benchmarks.vercel);
+  }
+  if (benchmarks.agentgrade?.available) {
+    printBenchmarkBlock("AgentGrade", "agentgrade", benchmarks.agentgrade);
+  }
 }
 
 function scoreColor(pct) {

package/src/benchmark/vercel.js

@@ -0,0 +1,57 @@
+import { execFileSync } from "child_process";
+
+export async function runVercel(url) {
+  try {
+    const output = execFileSync(
+      "npx",
+      ["@vercel/agent-readability", "audit", url, "--json"],
+      { timeout: 60000, encoding: "utf8", stdio: ["pipe", "pipe", "pipe"] },
+    );
+
+    const result = JSON.parse(output);
+    const score = result.score ?? 0;
+    const maxScore = 100;
+
+    const categories = {};
+    for (const [key, cat] of Object.entries(result.categories || {})) {
+      categories[key] = {
+        name: key.replace(/_/g, " "),
+        score: cat.passed,
+        maxScore: cat.total,
+        percentage:
+          cat.total > 0 ? Math.round((cat.passed / cat.total) * 100) : 0,
+      };
+    }
+
+    const checks = [];
+    for (const cat of Object.values(result.categories || {})) {
+      for (const check of cat.checks || []) {
+        checks.push({
+          id: check.name,
+          status: check.skipped ? "skip" : check.passed ? "pass" : "fail",
+          message: check.detail || check.hint || "",
+        });
+      }
+    }
+
+    return {
+      score,
+      maxScore,
+      grade: ratingToGrade(result.rating),
+      categories,
+      checks,
+      available: true,
+    };
+  } catch (err) {
+    console.warn(`Warning: Vercel benchmark failed for ${url}: ${err.message}`);
+    return { available: false, reason: err.message?.slice(0, 100) };
+  }
+}
+
+function ratingToGrade(rating) {
+  if (rating === "Excellent") return "A";
+  if (rating === "Good") return "B";
+  if (rating === "Fair") return "C";
+  if (rating === "Poor") return "D";
+  return "F";
+}

package/src/scan.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { createInterface } from "readline";
-import { execSync } from "child_process";
+import { execFileSync } from "child_process";
 import { runAllBenchmarks, printBenchmarks } from "./benchmark/index.js";
 import { saveResult } from "./history/index.js";
 
@@ -9,7 +9,11 @@ export async function scan(opts) {
 
   if (!json) {
     console.log(chalk.bold("\n  aeo-ready") + chalk.dim(` — ${url}\n`));
-    console.log(chalk.dim("  Checking agentic-seo · Cloudflare · Fern...\n"));
+    console.log(
+      chalk.dim(
+        "  Checking agentic-seo · Cloudflare · Fern · Vercel · AgentGrade...\n",
+      ),
+    );
   }
 
   const benchmarks = await runAllBenchmarks(url, dir);
@@ -55,6 +59,12 @@ function collectScores(benchmarks) {
   if (benchmarks.fern?.available) {
     scores.push(benchmarks.fern.score);
   }
+  if (benchmarks.vercel?.available) {
+    scores.push(benchmarks.vercel.score);
+  }
+  if (benchmarks.agentgrade?.available) {
+    scores.push(benchmarks.agentgrade.score);
+  }
   return scores;
 }
 
@@ -100,7 +110,10 @@ function printNextSteps(result) {
       (c) => c.status === "fail" || c.status === "warn",
     ) || [];
   if (fernFails.length > 0) {
-    steps.push([`npx afdocs ${result.url}`, `${fernFails.length} Fern issues`]);
+    steps.push([
+      `npx afdocs check ${result.url}`,
+      `${fernFails.length} Fern issues`,
+    ]);
   }
 
   steps.push([
@@ -138,7 +151,7 @@ async function promptFix(result, dir) {
 
   console.log(chalk.dim(`  Running: npx agentic-seo init ${targetDir}\n`));
   try {
-    execSync(`npx agentic-seo init ${targetDir}`, {
+    execFileSync("npx", ["agentic-seo", "init", targetDir], {
       stdio: "inherit",
     });
   } catch (err) {
@@ -150,9 +163,11 @@ async function promptFix(result, dir) {
       (c) => c.status === "fail" || c.status === "warn",
     ) || [];
   if (fernFails.length > 0) {
-    console.log(chalk.dim(`\n  Running: npx afdocs ${result.url}\n`));
+    console.log(chalk.dim(`\n  Running: npx afdocs check ${result.url}\n`));
     try {
-      execSync(`npx afdocs ${result.url}`, { stdio: "inherit" });
+      execFileSync("npx", ["afdocs", "check", result.url], {
+        stdio: "inherit",
+      });
     } catch (err) {
       console.log(chalk.red(`\n  afdocs failed: ${err.message}\n`));
     }

package/src/utils/fetch.js

@@ -1,42 +0,0 @@
-const DEFAULT_TIMEOUT = 10000;
-const USER_AGENT = "aeo-ready/1.3 (AEO benchmark aggregator)";
-
-export async function fetchUrl(url, opts = {}) {
-  const controller = new AbortController();
-  const timeout = setTimeout(
-    () => controller.abort(),
-    opts.timeout || DEFAULT_TIMEOUT,
-  );
-
-  try {
-    const res = await fetch(url, {
-      signal: controller.signal,
-      headers: {
-        "User-Agent": USER_AGENT,
-        ...opts.headers,
-      },
-      redirect: "follow",
-    });
-    const text = await res.text();
-    return {
-      status: res.status,
-      text,
-      headers: Object.fromEntries(res.headers),
-    };
-  } catch (err) {
-    if (err.name === "AbortError") {
-      return { status: 0, text: "", headers: {}, error: "timeout" };
-    }
-    return { status: 0, text: "", headers: {}, error: err.message };
-  } finally {
-    clearTimeout(timeout);
-  }
-}
-
-export function resolveUrl(base, path) {
-  try {
-    return new URL(path, base).href;
-  } catch {
-    return null;
-  }
-}