Build a client-ready
SEO audit PDF.

import { readFileSync, writeFileSync } from "node:fs";
import { PDFDocument, StandardFonts, rgb } from "pdf-lib";

function buildOptimizer(report, { minCoverage = 0.5, ignoredTerms = [] } = {}) {
  if (minCoverage < 0 || minCoverage > 1 || !Number.isFinite(minCoverage)) {
    throw new Error("minCoverage must be between 0 and 1.");
  }
  const entities = report.entity_coverage?.natural_language_entities;
  const matrix = report.competitor_term_coverage;
  if (!Array.isArray(entities) || !Array.isArray(matrix?.domains) || !Array.isArray(matrix?.terms)) {
    throw new Error("Expected entity_coverage and competitor_term_coverage arrays.");
  }
  const key = (text) => String(text).trim().toLowerCase();
  const statuses = new Map(entities.map((row) => [key(row.entity), row.coverage_status]));
  const ignored = new Set(ignoredTerms.map(key));
  const seen = new Set();
  const gaps = [];
  for (const row of matrix.terms) {
    const counts = row.competitor_counts;
    if (!Array.isArray(counts) || counts.length !== matrix.domains.length ||
        counts.some((n) => typeof n !== "number" || !Number.isFinite(n) || n < 0)) {
      throw new Error("Competitor counts must align with domains and contain numbers.");
    }
    const term = key(row.keyword);
    if (!term || seen.has(term)) continue;
    seen.add(term);
    // Require both signals; present_not_entity is already present in the page.
    if (statuses.get(term) !== "missing" || row.your_url_count !== 0 || ignored.has(term)) continue;
    const competitorPages = counts.filter((n) => n > 0).length;
    const comparedPages = counts.length;
    if (!comparedPages || !competitorPages || competitorPages / comparedPages < minCoverage) continue;
    gaps.push({
      id: "coverage:" + term, term: row.keyword,
      importance: Number.isFinite(row.importance) ? row.importance : 0,
      competitorPages, comparedPages,
      prevalence: competitorPages / comparedPages,
      status: "needs_review",
    });
  }
  gaps.sort((a, b) => b.prevalence - a.prevalence || b.importance - a.importance ||
    (a.term < b.term ? -1 : a.term > b.term ? 1 : 0));
  const gain = report.originality?.information_gain;
  const ideas = gain?.potential_uncovered_topics_for_information_gain;
  return {
    jobId: report.jobId,
    targetUrl: report.meta?.url ?? null,
    keyword: report.meta?.target_keyword ?? null,
    region: report.meta?.location ?? null,
    score: report.on_page_optimization?.score ?? null,
    scoreAlgorithm: report.on_page_optimization?.algorithm_version ?? null,
    comparedPages: matrix.domains.length,
    gaps,
    originalIdeas: {
      available: Array.isArray(ideas),
      items: Array.isArray(ideas) ? [...new Set(ideas.filter((s) => typeof s === "string" && s.trim()))] : [],
      uniqueDataPoints: gain?.unique_data_points ?? null,
    },
  };
}

function buildAudit(report, review) {
  const text = (value, name, max = 1200) => {
    if (typeof value !== "string" || !value.trim() || value.length > max) {
      throw new Error(name + " must be nonempty text, at most " + max + " characters.");
    }
    return value.trim();
  };
  const number = (value) => typeof value === "number" && Number.isFinite(value);
  if (!report.jobId || report.jobId !== review.jobId) {
    throw new Error("Review notes must match this report's jobId.");
  }
  const queue = buildOptimizer(report);
  const gaps = new Map(queue.gaps.map((row) => [row.term.trim().toLowerCase(), row]));
  if (!Array.isArray(review.actions) || review.actions.length > 8) {
    throw new Error("Review actions must be an array with at most 8 entries.");
  }
  const used = new Set();
  const actions = review.actions.map((item) => {
    let evidence;
    if (item.kind === "coverage") {
      const term = text(item.term, "term", 120).toLowerCase();
      const gap = gaps.get(term);
      if (!gap) throw new Error("No qualifying missing-term evidence for: " + term);
      if (used.has(term)) throw new Error("Duplicate review term: " + term);
      used.add(term);
      evidence = '"' + gap.term + '" is missing from this page and appears on ' +
        gap.competitorPages + " of " + gap.comparedPages + " compared pages.";
    } else if (item.kind === "research") {
      if (used.has("research")) throw new Error("Duplicate research action.");
      used.add("research");
      const data = queue.originalIdeas.uniqueDataPoints;
      if (!number(data?.your_count) || data.your_count < 0 ||
          !number(data?.page1_average) || data.page1_average < 0) {
        throw new Error("Research action needs unique_data_points evidence.");
      }
      evidence = "The information-gain analysis detected " + data.your_count +
        " unique numeric data points on this page; the comparison-page average is " +
        data.page1_average + ". Review the page before planning new research.";
    } else throw new Error("Unknown action kind.");
    return {
      title: text(item.title, "title", 100),
      action: text(item.action, "action"),
      verify: text(item.verify, "verify", 500),
      owner: text(item.owner, "owner", 80),
      effort: text(item.effort, "effort", 80),
      evidence,
    };
  });
  const score = (value) => number(value) && value >= 0 && value <= 100 ? value : null;
  return {
    jobId: report.jobId,
    brand: text(review.brand, "brand", 80),
    client: text(review.client, "client", 120),
    summary: text(review.summary, "summary"),
    url: text(report.meta?.url, "URL", 2000),
    keyword: text(report.meta?.target_keyword, "keyword", 200),
    region: text(report.meta?.location, "region", 80),
    score: score(report.on_page_optimization?.score),
    originality: score(report.originality?.score),
    comparedPages: queue.comparedPages,
    actions,
  };
}

async function renderAudit(audit) {
  const pdf = await PDFDocument.create({ updateMetadata: false });
  pdf.setTitle("On-page SEO audit | " + audit.client);
  pdf.setAuthor(audit.brand);
  pdf.setSubject("Report reference: " + audit.jobId);
  const regular = await pdf.embedFont(StandardFonts.Helvetica);
  const bold = await pdf.embedFont(StandardFonts.HelveticaBold);
  const ink = rgb(0.10, 0.16, 0.21), muted = rgb(0.35, 0.41, 0.45);
  const accent = rgb(0.02, 0.43, 0.39), line = rgb(0.84, 0.89, 0.88);
  const width = 499, margin = 48;
  let page, y;
  const newPage = () => {
    page = pdf.addPage([595.28, 841.89]);
    page.drawRectangle({ x: margin, y: 801, width: 28, height: 4, color: accent });
    y = 770;
  };
  function wrap(value, font, size) {
    const lines = [];
    let current = "";
    for (const word of String(value).split(/\s+/)) {
      const next = current ? current + " " + word : word;
      if (font.widthOfTextAtSize(next, size) <= width) { current = next; continue; }
      if (current) lines.push(current);
      current = "";
      for (const char of word) {
        if (font.widthOfTextAtSize(current + char, size) > width) {
          lines.push(current); current = "";
        }
        current += char;
      }
    }
    if (current) lines.push(current);
    return lines;
  }
  function text(value, size = 11, font = regular, color = ink, after = 10) {
    let lines;
    try { lines = wrap(value, font, size); }
    catch { throw new Error("This template needs an embedded Unicode font for that text."); }
    for (const value of lines) {
      if (y < 86) newPage();
      page.drawText(value, { x: margin, y, size, font, color });
      y -= size * 1.45;
    }
    y -= after;
  }
  function heading(value) {
    if (y < 175) newPage();
    text(value, 15, bold, ink, 8);
  }
  const score = (value) => value == null ? "Not available" : value + "/100";
  newPage();
  text(audit.brand.toUpperCase(), 10, bold, accent, 15);
  text("On-page SEO audit", 31, bold, ink, 6);
  text("Prepared for " + audit.client, 12, regular, muted, 15);
  text(audit.url, 10, regular, muted, 4);
  text('Keyword: "' + audit.keyword + '"  |  Region: ' + audit.region, 10, regular, muted, 18);
  text("ON-PAGE SCORE   " + score(audit.score), 20, bold, accent, 4);
  text(audit.comparedPages + " comparison pages inform the coverage analysis.", 10, regular, muted, 15);
  text(audit.summary, 12, regular, ink, 18);
  heading("Recommended next steps");
  if (!audit.actions.length) text("No actions were selected for this report. Review the scan before proposing changes.");
  audit.actions.forEach((item, i) => {
    if (y < 170) newPage();
    text(String(i + 1).padStart(2, "0") + "  " + item.title, 13, bold, ink, 4);
    text(item.owner + "  |  " + item.effort, 9, regular, accent, 6);
    text(item.action, 11, regular, ink, 14);
  });
  newPage();
  text("EVIDENCE & FOLLOW-THROUGH", 10, bold, accent, 15);
  text("Why these actions", 27, bold, ink, 8);
  text("Recommendations combine scan evidence with an editorial review of this page.", 11, regular, muted, 20);
  audit.actions.forEach((item, i) => {
    heading(String(i + 1).padStart(2, "0") + "  " + item.title);
    text(item.evidence, 11, regular, ink, 5);
    text("Check: " + item.verify, 10, regular, muted, 18);
  });
  heading("Read the scores in context");
  text("On-page: " + score(audit.score) + ". Originality: " + score(audit.originality) +
    ". These are separate report measures; they are not percentages of SEO work completed or ranking forecasts.", 10, regular, muted, 12);
  heading("Scope and next check");
  text("This report covers one URL, keyword, and region. It is a content and relevance review, not a site-wide technical or backlink audit. Priorities, owners, and actions were selected by the reviewer.", 10, regular, muted, 8);
  text("After publishing the agreed edits, scan the same URL and keyword again. Check whether the topics are now covered. Measure search traffic separately in your analytics.", 10, regular, muted, 8);
  const pages = pdf.getPages();
  pages.forEach((p, i) => {
    p.drawLine({ start: { x: margin, y: 53 }, end: { x: margin + width, y: 53 }, thickness: 0.7, color: line });
    p.drawText("ON-PAGE SEO AUDIT", { x: margin, y: 36, size: 8, font: regular, color: muted });
    p.drawText((i + 1) + " / " + pages.length, { x: 510, y: 36, size: 8, font: regular, color: muted });
  });
  return pdf.save();
}

const [reportPath, reviewPath, outputPath = "seo-audit.pdf"] = process.argv.slice(2);
if (!reportPath || !reviewPath) throw new Error("Usage: node render-audit.mjs report.json review.json [output.pdf]");
const report = JSON.parse(readFileSync(reportPath, "utf8"));
const review = JSON.parse(readFileSync(reviewPath, "utf8"));
const audit = buildAudit(report, review);
const bytes = await renderAudit(audit);
writeFileSync(outputPath, bytes);
console.log("Saved " + outputPath);