aeo-ready 1.1.0 → 1.2.0

package/src/dashboard/sections/trend-chart.js

@@ -6,54 +6,42 @@ export function renderTrendChart(history) {
   const scans = history.scans.slice(-20);
   const width = 700;
   const height = 200;
-  const padding = { top: 20, right: 20, bottom: 30, left: 40 };
-  const chartW = width - padding.left - padding.right;
-  const chartH = height - padding.top - padding.bottom;
-
-  const maxScore = 100;
+  const pad = { top: 20, right: 20, bottom: 30, left: 40 };
+  const chartW = width - pad.left - pad.right;
+  const chartH = height - pad.top - pad.bottom;
   const xStep = scans.length > 1 ? chartW / (scans.length - 1) : chartW;
 
-  function toPoint(index, value) {
-    const x = padding.left + index * xStep;
-    const y = padding.top + chartH - (value / maxScore) * chartH;
-    return { x, y };
+  function toY(value) {
+    return pad.top + chartH - (value / 100) * chartH;
   }
 
   function polyline(values, color) {
-    const points = values.map((v, i) => toPoint(i, v));
-    const d = points
-      .map(
-        (p, i) => `${i === 0 ? "M" : "L"} ${p.x.toFixed(1)} ${p.y.toFixed(1)}`,
-      )
-      .join(" ");
-    return `<path d="${d}" fill="none" stroke="${color}" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>`;
-  }
-
-  function dots(values, color) {
-    return values
-      .map((v, i) => {
-        const p = toPoint(i, v);
-        return `<circle cx="${p.x.toFixed(1)}" cy="${p.y.toFixed(1)}" r="3" fill="${color}"/>`;
-      })
-      .join("\n");
+    const pts = values.map(
+      (v, i) =>
+        `${i === 0 ? "M" : "L"} ${(pad.left + i * xStep).toFixed(1)} ${toY(v ?? 0).toFixed(1)}`,
+    );
+    return `<path d="${pts.join(" ")}" fill="none" stroke="${color}" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/>`;
   }
 
-  const overall = scans.map((s) => s.score);
-  const agent = scans.map((s) => (s.agentReadiness ?? 0) * 2);
-  const vis = scans.map((s) => (s.aiVisibility ?? 0) * 2);
+  const agenticSeo = scans.map((s) => s.agenticSeo ?? 0);
+  const cloudflare = scans.map((s) =>
+    s.cloudflare != null && s.cloudflareMax
+      ? Math.round((s.cloudflare / s.cloudflareMax) * 100)
+      : 0,
+  );
+  const fern = scans.map((s) => s.fern ?? 0);
 
-  const gridLines = [0, 25, 50, 75, 100]
+  const grid = [0, 25, 50, 75, 100]
     .map((v) => {
-      const y = padding.top + chartH - (v / maxScore) * chartH;
-      return `<line x1="${padding.left}" y1="${y}" x2="${width - padding.right}" y2="${y}" stroke="#21262d" stroke-width="1"/>
-<text x="${padding.left - 8}" y="${y + 4}" text-anchor="end" fill="#8b949e" font-size="10">${v}</text>`;
+      const y = toY(v);
+      return `<line x1="${pad.left}" y1="${y}" x2="${width - pad.right}" y2="${y}" stroke="#21262d"/><text x="${pad.left - 8}" y="${y + 4}" text-anchor="end" fill="#8b949e" font-size="10">${v}</text>`;
     })
     .join("\n");
 
-  const xLabels = scans
+  const labels = scans
     .map((s, i) => {
       if (scans.length <= 10 || i % Math.ceil(scans.length / 8) === 0) {
-        const x = padding.left + i * xStep;
+        const x = pad.left + i * xStep;
         const label = s.timestamp ? s.timestamp.slice(5, 10) : "";
         return `<text x="${x}" y="${height - 5}" text-anchor="middle" fill="#8b949e" font-size="10">${label}</text>`;
       }
@@ -61,18 +49,15 @@ export function renderTrendChart(history) {
     })
     .join("\n");
 
-  const svg = `<h2 id="trends">Score Trends</h2>
+  return `<h2 id="trends">Score Trends</h2>
 <svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
-${gridLines}
-${xLabels}
-${polyline(agent, "#79c0ff")}
-${polyline(vis, "#d29922")}
-${polyline(overall, "#f0f6fc")}
-${dots(overall, "#f0f6fc")}
-<text x="${width - padding.right}" y="${padding.top - 5}" text-anchor="end" fill="#f0f6fc" font-size="10">Overall</text>
-<text x="${width - padding.right - 80}" y="${padding.top - 5}" text-anchor="end" fill="#79c0ff" font-size="10">Agent (x2)</text>
-<text x="${width - padding.right - 180}" y="${padding.top - 5}" text-anchor="end" fill="#d29922" font-size="10">Visibility (x2)</text>
+${grid}
+${labels}
+${polyline(agenticSeo, "#f85149")}
+${polyline(cloudflare, "#3fb950")}
+${polyline(fern, "#79c0ff")}
+<text x="${width - pad.right}" y="${pad.top - 5}" text-anchor="end" fill="#f85149" font-size="10">agentic-seo</text>
+<text x="${width - pad.right - 90}" y="${pad.top - 5}" text-anchor="end" fill="#3fb950" font-size="10">Cloudflare</text>
+<text x="${width - pad.right - 170}" y="${pad.top - 5}" text-anchor="end" fill="#79c0ff" font-size="10">Fern</text>
 </svg>`;
-
-  return svg;
 }

package/src/history/index.js

@@ -1,7 +1,7 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
 
-const DIR_NAME = ".agent-web";
+const DIR_NAME = ".aeo-ready";
 const HISTORY_FILE = "history.json";
 
 export async function saveResult(result, baseDir) {
@@ -14,17 +14,12 @@ export async function saveResult(result, baseDir) {
   history.scans.push({
     id: generateId(),
     timestamp: result.timestamp,
-    score: result.score,
-    grade: result.grade,
-    siteType: result.siteType,
-    target: result.target,
-    agentReadiness: result.agentReadiness.score,
-    aiVisibility: result.aiVisibility.score,
-    benchmarks: {
-      agenticSeo: result.benchmarks?.agenticSeo?.score ?? null,
-      cloudflare: result.benchmarks?.cloudflare?.score ?? null,
-      fern: result.benchmarks?.fern?.score ?? null,
-    },
+    url: result.url,
+    averageScore: result.averageScore,
+    agenticSeo: result.benchmarks?.agenticSeo?.score ?? null,
+    cloudflare: result.benchmarks?.cloudflare?.score ?? null,
+    cloudflareMax: result.benchmarks?.cloudflare?.maxScore ?? null,
+    fern: result.benchmarks?.fern?.score ?? null,
   });
 
   writeFileSync(historyPath, JSON.stringify(history, null, 2));
@@ -34,9 +29,7 @@ export function loadHistory(historyPath) {
   if (existsSync(historyPath)) {
     try {
       return JSON.parse(readFileSync(historyPath, "utf8"));
-    } catch {
-      /* corrupted — start fresh */
-    }
+    } catch {}
   }
   return { scans: [] };
 }

package/src/scan.js

@@ -1,65 +1,38 @@
 import chalk from "chalk";
-import { fetchUrl, resolveUrl } from "./utils/fetch.js";
-import { detectSiteType } from "./utils/detect-type.js";
-import { runDiscoveryChecks } from "./checks/agent-readiness/discovery.js";
-import { runContentStructureChecks } from "./checks/agent-readiness/content-structure.js";
-import { runCapabilityChecks } from "./checks/agent-readiness/capability.js";
-import { runActionableChecks } from "./checks/agent-readiness/actionable.js";
-import { runStructuredDataChecks } from "./checks/ai-visibility/structured-data.js";
-import { runCitationReadinessChecks } from "./checks/ai-visibility/citation-readiness.js";
-import { runAuthorityChecks } from "./checks/ai-visibility/authority.js";
-import { runFreshnessChecks } from "./checks/ai-visibility/freshness.js";
 import { runAllBenchmarks, printBenchmarks } from "./benchmark/index.js";
 import { saveResult } from "./history/index.js";
 import { generateDashboard } from "./dashboard/generate.js";
-import { readdirSync, readFileSync, existsSync } from "fs";
-import { join } from "path";
 import { exec } from "child_process";
 
 export async function scan(opts) {
-  const { url, dir, json, benchmark } = opts;
-  const mode = url ? "url" : "repo";
+  const { url, json } = opts;
 
   if (!json) {
     console.log(
-      chalk.bold("\n  aeo-ready") + chalk.dim(" — AI readiness audit\n"),
+      chalk.bold("\n  aeo-ready") + chalk.dim(" — AEO benchmark aggregator\n"),
     );
+    console.log(chalk.dim(`  Scanning ${url}...\n`));
   }
 
-  const context = await gatherContext(mode, url, dir);
-
-  if (!json) {
-    console.log(chalk.dim(`  Mode: ${mode} | Type: ${context.siteType}\n`));
-  }
-
-  const agentReadiness = await runAgentReadinessChecks(context);
-  const aiVisibility = await runAiVisibilityChecks(context);
-
-  const score = agentReadiness.score + aiVisibility.score;
-  const grade = scoreToGrade(score);
-
-  let benchmarkResult = null;
-  if (benchmark) {
-    benchmarkResult = await runAllBenchmarks(mode === "url" ? url : dir);
-  }
+  const benchmarks = await runAllBenchmarks(url);
+  const scores = collectScores(benchmarks);
+  const averageScore =
+    scores.length > 0
+      ? Math.round(scores.reduce((s, v) => s + v, 0) / scores.length)
+      : 0;
 
   const result = {
-    score,
-    grade,
-    siteType: context.siteType,
-    mode,
-    target: url || dir,
+    url,
     timestamp: new Date().toISOString(),
-    agentReadiness,
-    aiVisibility,
-    benchmarks: benchmarkResult,
+    averageScore,
+    benchmarks,
   };
 
   if (!json) {
     printReport(result);
   }
 
-  const baseDir = dir || process.cwd();
+  const baseDir = process.cwd();
   await saveResult(result, baseDir);
 
   if (!json) {
@@ -71,278 +44,71 @@ export async function scan(opts) {
   return result;
 }
 
-async function gatherContext(mode, url, dir) {
-  const context = { mode, url, dir, pages: {}, files: [], html: "" };
-
-  if (mode === "url") {
-    const homepage = await fetchUrl(url);
-    context.html = homepage.text;
-    context.pages.home = homepage;
-
-    const fetches = [
-      fetchUrl(resolveUrl(url, "/llms.txt")),
-      fetchUrl(resolveUrl(url, "/robots.txt")),
-      fetchUrl(resolveUrl(url, "/sitemap.xml")),
-      fetchUrl(resolveUrl(url, "/.well-known/agent.json")),
-      fetchUrl(resolveUrl(url, "/openapi.json")),
-    ];
-
-    const [llms, robots, sitemap, agentJson, openapi] =
-      await Promise.all(fetches);
-    context.pages.llmsTxt = llms;
-    context.pages.robotsTxt = robots;
-    context.pages.sitemap = sitemap;
-    context.pages.agentJson = agentJson;
-    context.pages.openapi = openapi;
-  } else {
-    const fileList = listFiles(dir);
-    context.files = fileList;
-    context.fileContents = {};
-    for (const f of fileList) {
-      try {
-        context.fileContents[f] = readFileSync(join(dir, f), "utf8");
-      } catch {
-        /* skip binary/unreadable */
-      }
-    }
-    const indexHtml = [
-      "index.html",
-      "public/index.html",
-      "dist/index.html",
-    ].find((p) => existsSync(join(dir, p)));
-    if (indexHtml) {
-      context.html = readFileSync(join(dir, indexHtml), "utf8");
-    }
+function collectScores(benchmarks) {
+  const scores = [];
+  if (benchmarks.agenticSeo?.available) {
+    scores.push(benchmarks.agenticSeo.score);
   }
-
-  context.siteType = detectSiteType({
-    html: context.html,
-    files: context.files,
-    url,
-  });
-
-  return context;
-}
-
-function listFiles(dir) {
-  const skip = new Set([
-    "node_modules",
-    ".git",
-    "dist",
-    "build",
-    ".next",
-    ".venv",
-    "__pycache__",
-    "target",
-    ".aeo-ready",
-  ]);
-  const results = [];
-
-  function walk(current, prefix) {
-    let entries;
-    try {
-      entries = readdirSync(join(dir, current), { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (skip.has(entry.name)) continue;
-      const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
-      if (entry.isDirectory()) {
-        walk(join(current, entry.name), rel);
-      } else {
-        results.push(rel);
-      }
-    }
+  if (benchmarks.cloudflare?.available) {
+    scores.push(
+      Math.round(
+        (benchmarks.cloudflare.score / benchmarks.cloudflare.maxScore) * 100,
+      ),
+    );
   }
-
-  walk("", "");
-  return results;
-}
-
-async function runAgentReadinessChecks(context) {
-  const discovery = await runDiscoveryChecks(context);
-  const contentStructure = await runContentStructureChecks(context);
-  const capability = await runCapabilityChecks(context);
-  const actionable = await runActionableChecks(context);
-
-  const score =
-    discovery.score +
-    contentStructure.score +
-    capability.score +
-    actionable.score;
-
-  return {
-    score,
-    maxScore: 50,
-    categories: { discovery, contentStructure, capability, actionable },
-  };
-}
-
-async function runAiVisibilityChecks(context) {
-  const structuredData = await runStructuredDataChecks(context);
-  const citationReadiness = await runCitationReadinessChecks(context);
-  const authority = await runAuthorityChecks(context);
-  const freshness = await runFreshnessChecks(context);
-
-  const score =
-    structuredData.score +
-    citationReadiness.score +
-    authority.score +
-    freshness.score;
-
-  return {
-    score,
-    maxScore: 50,
-    categories: { structuredData, citationReadiness, authority, freshness },
-  };
-}
-
-function scoreToGrade(score) {
-  if (score >= 80) return "A";
-  if (score >= 65) return "B";
-  if (score >= 50) return "C";
-  if (score >= 35) return "D";
-  return "F";
+  if (benchmarks.fern?.available) {
+    scores.push(benchmarks.fern.score);
+  }
+  return scores;
 }
 
 function printReport(result) {
-  const { score, grade, agentReadiness, aiVisibility, benchmarks } = result;
+  const { benchmarks, averageScore } = result;
 
-  const gradeColor =
-    grade === "A"
-      ? chalk.green
-      : grade === "B"
-        ? chalk.cyan
-        : grade === "C"
-          ? chalk.yellow
-          : chalk.red;
-
-  console.log(
-    `  ${bar(score, 100, 40)}  ${gradeColor.bold(grade)} ${score}/100\n`,
-  );
+  printBenchmarks(benchmarks);
 
+  const gc =
+    averageScore >= 80
+      ? chalk.green
+      : averageScore >= 50
+        ? chalk.yellow
+        : chalk.red;
   console.log(
-    chalk.dim(
-      "  Agent Readiness — can AI agents find, read, and use your site?",
-    ),
+    chalk.dim("  ─────────────────────────────────────────────────\n"),
   );
   console.log(
-    chalk.dim(
-      "  AI Visibility — how accurately do AI search engines describe you?",
-    ),
+    `  Average across all sources: ${gc.bold(`${averageScore}/100`)}\n`,
   );
 
-  if (agentReadiness.score < 25) {
+  if (averageScore < 80) {
+    console.log(chalk.bold("  Fix it:\n"));
     console.log(
-      chalk.dim(
-        "\n  Agent Readiness is low — AI engines can't cite what they can't read.",
-      ),
+      chalk.dim("    npx agentic-seo init") +
+        "          scaffold llms.txt, AGENTS.md, skill.md",
     );
-    console.log(chalk.dim("  Fix the agent side first. Visibility follows."));
-  }
-  console.log("");
 
-  printScorecard("Agent Readiness", agentReadiness);
-  printScorecard("AI Visibility", aiVisibility);
-
-  const allChecks = [
-    ...Object.values(agentReadiness.categories),
-    ...Object.values(aiVisibility.categories),
-  ].flatMap((c) => c.checks);
-  const passed = allChecks.filter((c) => c.passed).length;
-  const failed = allChecks.filter((c) => !c.passed && c.points === 0).length;
-  const partial = allChecks.length - passed - failed;
-
-  console.log(
-    chalk.dim(
-      `  ${chalk.green(passed + " passed")} · ${partial ? chalk.yellow(partial + " partial") + " · " : ""}${chalk.red(failed + " failed")} · ${allChecks.length} checks total\n`,
-    ),
-  );
-
-  if (benchmarks) {
-    printBenchmarks(benchmarks);
-  }
-
-  if (failed + partial > 0) {
-    console.log(chalk.bold("  Next steps:\n"));
-    const topFixes = allChecks
-      .filter((c) => !c.passed && c.fix)
-      .sort(
-        (a, b) =>
-          b.maxPoints - (b.points || 0) - (a.maxPoints - (a.points || 0)),
-      )
-      .slice(0, 3);
-    for (const fix of topFixes) {
-      console.log(chalk.dim(`    - ${fix.fix}`));
+    const cfFails =
+      benchmarks.cloudflare?.checks?.filter((c) => c.status === "fail") || [];
+    for (const fail of cfFails.slice(0, 2)) {
+      console.log(
+        chalk.dim(`    Cloudflare: ${fail.id}`) +
+          chalk.dim(` — see isitagentready.com for fix`),
+      );
     }
-    console.log(
-      chalk.dim(
-        `\n  Run ${chalk.bold("npx aeo-ready scan --fix")} to auto-fix what we can.`,
-      ),
-    );
-    console.log(
-      chalk.dim(
-        "  Open the dashboard for step-by-step guides on everything else.\n",
-      ),
-    );
-  }
-}
-
-function printScorecard(name, scorecard) {
-  const pct = Math.round((scorecard.score / scorecard.maxScore) * 100);
-  console.log(
-    chalk.bold(`  ${name}`) +
-      chalk.dim(` ${scorecard.score}/${scorecard.maxScore} (${pct}%)`),
-  );
 
-  for (const [catName, cat] of Object.entries(scorecard.categories)) {
-    const label = formatCategoryName(catName);
-    const catPct = Math.round((cat.score / cat.maxScore) * 100);
-    const icon =
-      catPct >= 80
-        ? chalk.green("✓")
-        : catPct >= 40
-          ? chalk.yellow("◑")
-          : chalk.red("✗");
-    console.log(
-      `  ${icon} ${label.padEnd(28)} ${bar(cat.score, cat.maxScore, 20)} ${chalk.dim(`${cat.score}/${cat.maxScore} (${catPct}%)`)}`,
-    );
-
-    for (const check of cat.checks) {
-      if (check.passed) {
-        console.log(
-          chalk.green(`      +`) +
-            chalk.dim(` ${check.name} [${check.points}]`),
-        );
-      } else {
-        console.log(
-          chalk.red(`      -`) +
-            ` ${check.name} ` +
-            chalk.dim(`[${check.points || 0}/${check.maxPoints}]`),
-        );
-        if (check.fix) {
-          console.log(chalk.dim(`        ${check.fix}`));
-        }
-      }
+    const fernFails =
+      benchmarks.fern?.checks?.filter(
+        (c) => c.status === "fail" || c.status === "warn",
+      ) || [];
+    if (fernFails.length > 0) {
+      console.log(
+        chalk.dim(`    Fern: ${fernFails.length} issues`) +
+          chalk.dim(` — run npx afdocs ${result.url}`),
+      );
     }
-  }
-  console.log("");
-}
-
-function bar(value, max, width) {
-  const filled = max > 0 ? Math.round((value / max) * width) : 0;
-  const empty = width - filled;
-  const pct = max > 0 ? Math.round((value / max) * 100) : 0;
-  const color = pct >= 80 ? chalk.green : pct >= 50 ? chalk.yellow : chalk.red;
-  return color("█".repeat(filled)) + chalk.dim("░".repeat(empty));
-}
 
-function formatCategoryName(camelCase) {
-  return camelCase
-    .replace(/([A-Z])/g, " $1")
-    .replace(/^./, (c) => c.toUpperCase())
-    .trim();
+    console.log(chalk.dim("\n  Fix, then re-scan to track improvement.\n"));
+  }
 }
 
 function openInBrowser(filePath) {