@rivi-software/agentic-seo-check 0.1.0 → 0.2.0

package/dist/core/audit.js

@@ -1,32 +1,274 @@
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { crawlSite } from './crawl.js';
-import { DEFAULT_USER_AGENT, fetchPage, toResponseInfo } from './fetch.js';
-import { extractPage } from './html/extract.js';
-import { runLighthouse, LighthouseUnavailableError } from './lighthouse.js';
-import { performanceFindings } from './performance-rules.js';
-import { compareRender } from './render-rules.js';
-import { renderPage, RenderUnavailableError } from './render.js';
-import { runPageRules, sortFindings } from './rules/index.js';
-import { pageScore, siteScore } from './score.js';
-import { runSiteRules } from './site-rules.js';
-import { scanDirectory } from './static.js';
-import { buildSummary } from './summary.js';
-import { countFindings, DEFAULT_THRESHOLDS, } from './types.js';
-import { isHttpUrl } from './url.js';
-export const DEFAULT_CRAWL = { maxPages: 50, maxDepth: 3, concurrency: 5, delayMs: 0, maxLinkChecks: 200 };
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { crawlSite } from "./crawl.js";
+import { DEFAULT_USER_AGENT, fetchPage, toResponseInfo } from "./fetch.js";
+import { extractPage } from "./html/extract.js";
+import { runLighthouse, LighthouseUnavailableError } from "./lighthouse.js";
+import { performanceFindings } from "./performance-rules.js";
+import { compareRender } from "./render-rules.js";
+import { renderPage, RenderUnavailableError } from "./render.js";
+import { runPageRules, sortFindings } from "./rules/index.js";
+import { pageScore, siteScore } from "./score.js";
+import { runSiteRules } from "./site-rules.js";
+import { scanDirectory } from "./static.js";
+import { buildSummary } from "./summary.js";
+import { countFindings, DEFAULT_THRESHOLDS } from "./types.js";
+import { isHttpUrl } from "./url.js";
+export const DEFAULT_CRAWL = {
+    maxPages: 50,
+    maxDepth: 3,
+    concurrency: 5,
+    delayMs: 0,
+    maxLinkChecks: 200,
+};
+const toolFinding = (rule, message, url) => ({
+    rule,
+    severity: "info",
+    category: "tool",
+    message,
+    recommendation: "Install the optional dependency (see message) or run without this option. The rest of the audit is complete.",
+    url,
+});
+// The raw HTML is not kept on the audit (too large); re-fetch it for the render comparison.
+const rawHtmlFor = async (audit, options) => {
+    const res = await fetchPage(audit.response?.finalUrl ?? audit.url, options.fetch ?? {});
+    return res.body ?? "";
+};
+/** Renders the page in Chromium and compares it with the server HTML, on `audit.rendering`. */
+const renderFindings = async (audit, options, url) => {
+    options.onProgress?.({
+        phase: "render",
+        message: `Rendering ${url} with Playwright`,
+    });
+    try {
+        const rendered = await renderPage(url, {
+            timeoutMs: Math.max(options.fetch?.timeoutMs ?? 0, 30_000),
+            userAgent: options.fetch?.userAgent,
+            headers: options.fetch?.headers,
+        });
+        const rawPage = extractPage(await rawHtmlFor(audit, options), {
+            url,
+            includeSubdomains: options.includeSubdomains,
+        });
+        const renderedPage = extractPage(rendered.html, {
+            url: rendered.finalUrl,
+            siteHost: new URL(url).hostname,
+            includeSubdomains: options.includeSubdomains,
+        });
+        const { comparison, findings } = compareRender(rawPage, renderedPage, rendered.finalUrl, rendered.consoleErrors, audit.response);
+        audit.rendering = comparison;
+        return findings;
+    }
+    catch (error) {
+        return [
+            toolFinding("tool.render-unavailable", error instanceof RenderUnavailableError
+                ? error.message
+                : `Rendering failed: ${error instanceof Error ? error.message : String(error)}`, url),
+        ];
+    }
+};
+/** Runs Lighthouse on the page, on `audit.performance`. */
+const lighthouseFindings = async (audit, options, url) => {
+    options.onProgress?.({
+        phase: "lighthouse",
+        message: `Running Lighthouse (${options.formFactor ?? "mobile"}) on ${url}`,
+    });
+    try {
+        const perf = await runLighthouse(url, {
+            formFactor: options.formFactor ?? "mobile",
+            userAgent: options.fetch?.userAgent,
+            headers: options.fetch?.headers,
+        });
+        audit.performance = perf;
+        return performanceFindings(perf);
+    }
+    catch (error) {
+        return [
+            toolFinding("tool.lighthouse-unavailable", error instanceof LighthouseUnavailableError
+                ? error.message
+                : `Lighthouse failed: ${error instanceof Error ? error.message : String(error)}`, url),
+        ];
+    }
+};
+const enrichPage = async (audit, options) => {
+    const url = audit.response?.finalUrl ?? audit.url;
+    const extra = [];
+    if (options.render) {
+        extra.push(...(await renderFindings(audit, options, url)));
+    }
+    if (options.lighthouse) {
+        extra.push(...(await lighthouseFindings(audit, options, url)));
+    }
+    if (extra.length) {
+        const filtered = options.includeInfo === false
+            ? extra.filter((f) => f.severity !== "info")
+            : extra;
+        audit.findings = sortFindings([...audit.findings, ...filtered]);
+        audit.counts = countFindings(audit.findings);
+        audit.score = pageScore(audit.counts);
+    }
+};
+const auditRecord = (record, source, options) => {
+    const thresholds = { ...DEFAULT_THRESHOLDS, ...options.thresholds };
+    let findings = runPageRules({
+        page: record.page,
+        source,
+        response: record.response,
+        keyword: options.keyword,
+        thresholds,
+        depth: record.depth,
+    }, { disable: new Set(options.disableRules) });
+    if (options.includeInfo === false) {
+        findings = findings.filter((f) => f.severity !== "info");
+    }
+    const audit = {
+        schemaVersion: 1,
+        kind: "page",
+        target: record.file ?? record.requestedUrl,
+        url: record.file ?? record.url,
+        source,
+        auditedAt: new Date().toISOString(),
+        summary: buildSummary(record.page, record.response),
+        findings,
+        counts: countFindings(findings),
+        score: 0,
+        depth: record.depth,
+    };
+    if (record.response) {
+        audit.response = record.response;
+    }
+    audit.score = pageScore(audit.counts);
+    return audit;
+};
+export const rollupIssues = (pages) => {
+    const map = new Map();
+    for (const page of pages) {
+        const seenHere = new Set();
+        for (const f of page.findings) {
+            if (seenHere.has(f.rule)) {
+                continue;
+            }
+            seenHere.add(f.rule);
+            let entry = map.get(f.rule);
+            if (!entry) {
+                entry = {
+                    rule: f.rule,
+                    severity: f.severity,
+                    category: f.category,
+                    pages: 0,
+                    message: f.message,
+                    recommendation: f.recommendation,
+                    examples: [],
+                    urls: new Set(),
+                };
+                map.set(f.rule, entry);
+            }
+            entry.pages += 1;
+            entry.urls.add(page.url);
+        }
+    }
+    const rank = { error: 0, warning: 1, info: 2 };
+    return [...map.values()]
+        .toSorted((a, b) => rank[a.severity] - rank[b.severity] || b.pages - a.pages)
+        .map(({ urls, ...rest }) => ({
+        ...rest,
+        examples: [...urls].slice(0, 10),
+    }));
+};
+export const recomputeSite = (site) => {
+    const counts = countFindings(site.siteFindings);
+    for (const p of site.pages) {
+        counts.error += p.counts.error;
+        counts.warning += p.counts.warning;
+        counts.info += p.counts.info;
+    }
+    site.counts = counts;
+    site.issues = rollupIssues(site.pages);
+    site.score = siteScore(site.pages, site.siteFindings);
+};
+const buildSiteAudit = (result, source, target, options) => {
+    options.onProgress?.({
+        phase: "rules",
+        message: `Evaluating rules for ${result.records.length} pages`,
+    });
+    const thresholds = { ...DEFAULT_THRESHOLDS, ...options.thresholds };
+    const pages = result.records.map((record) => auditRecord(record, source === "directory" ? "file" : "url", options));
+    let siteFindings = runSiteRules({
+        startUrl: result.startUrl,
+        source,
+        pages: result.records,
+        linkChecks: result.linkChecks,
+        linkSources: result.linkSources,
+        externalChecks: result.externalChecks,
+        externalSources: result.externalSources,
+        robots: result.robots,
+        robotsAllows: result.robotsAllows,
+        blockedByRobots: result.blockedByRobots,
+        sitemaps: result.sitemaps,
+        probes: result.probes,
+        crawl: result.stats,
+        thresholds,
+        pathOnly: source === "directory",
+        unlinkedPages: result.unlinkedPages,
+    });
+    const disabled = new Set(options.disableRules);
+    siteFindings = sortFindings(siteFindings.filter((f) => !disabled.has(f.rule)));
+    if (options.includeInfo === false) {
+        siteFindings = siteFindings.filter((f) => f.severity !== "info");
+    }
+    const site = {
+        schemaVersion: 1,
+        kind: "site",
+        target,
+        source,
+        auditedAt: new Date().toISOString(),
+        crawl: result.stats,
+        robotsTxt: result.robots,
+        sitemaps: { ...result.sitemaps, urls: result.sitemaps.urls.slice(0, 200) },
+        pages: pages.toSorted((a, b) => (a.depth ?? 0) - (b.depth ?? 0) || a.score - b.score),
+        siteFindings,
+        issues: [],
+        counts: { error: 0, warning: 0, info: 0 },
+        score: 0,
+    };
+    recomputeSite(site);
+    return site;
+};
+/** Keeps only each page's summary when the caller asked for `pageDetail: "summary"`. */
+const applyPageDetail = (site, options) => {
+    if (options.pageDetail === "summary") {
+        site.pages = site.pages.map((p) => ({
+            ...p,
+            findings: [],
+            summary: { ...p.summary, headings: [], openGraph: {} },
+        }));
+    }
+    return site;
+};
 /** Audit an HTML string. `url` is used to resolve links and for display. */
-export async function auditHtml(html, input = {}, options = {}) {
-    const url = input.url ?? options.baseUrl ?? 'http://localhost/';
-    const page = extractPage(html, { url, includeSubdomains: options.includeSubdomains });
-    const source = input.source ?? 'html';
-    const thresholds = { ...DEFAULT_THRESHOLDS, ...(options.thresholds ?? {}) };
-    let findings = runPageRules({ page, source, response: input.response, keyword: options.keyword, thresholds, depth: input.depth }, { disable: new Set(options.disableRules ?? []) });
-    if (options.includeInfo === false)
-        findings = findings.filter((f) => f.severity !== 'info');
+// oxlint-disable-next-line eslint/require-await -- public API: it returns a promise like the other audit functions, so a throw reaches callers as a rejection
+export const auditHtml = async (html, input = {}, options = {}) => {
+    const url = input.url ?? options.baseUrl ?? "http://localhost/";
+    const page = extractPage(html, {
+        url,
+        includeSubdomains: options.includeSubdomains,
+    });
+    const source = input.source ?? "html";
+    const thresholds = { ...DEFAULT_THRESHOLDS, ...options.thresholds };
+    let findings = runPageRules({
+        page,
+        source,
+        response: input.response,
+        keyword: options.keyword,
+        thresholds,
+        depth: input.depth,
+    }, { disable: new Set(options.disableRules) });
+    if (options.includeInfo === false) {
+        findings = findings.filter((f) => f.severity !== "info");
+    }
     const audit = {
         schemaVersion: 1,
-        kind: 'page',
+        kind: "page",
         target: input.target ?? url,
         url: input.response?.finalUrl ?? url,
         source,
@@ -36,25 +278,27 @@ export async function auditHtml(html, input = {}, options = {}) {
         counts: countFindings(findings),
         score: 0,
     };
-    if (input.response)
+    if (input.response) {
         audit.response = input.response;
-    if (input.depth !== undefined)
+    }
+    if (input.depth !== undefined) {
         audit.depth = input.depth;
+    }
     audit.score = pageScore(audit.counts);
     return audit;
-}
+};
 /** Fetch and audit one URL. Optionally render and/or run Lighthouse. */
-export async function auditUrl(url, options = {}) {
+export const auditUrl = async (url, options = {}) => {
     const res = await fetchPage(url, options.fetch ?? {});
     const response = toResponseInfo(res);
-    const audit = await auditHtml(res.body ?? '', { url: res.finalUrl, response, source: 'url', target: url }, options);
+    const audit = await auditHtml(res.body ?? "", { url: res.finalUrl, response, source: "url", target: url }, options);
     if (res.error) {
         audit.findings.unshift({
-            rule: 'response.fetch-failed',
-            severity: 'error',
-            category: 'response',
+            rule: "response.fetch-failed",
+            severity: "error",
+            category: "response",
             message: `Could not fetch ${url}: ${res.error}`,
-            recommendation: 'Check that the URL is reachable from this machine (DNS, TLS, firewall, dev server running) and that it responds within the timeout.',
+            recommendation: "Check that the URL is reachable from this machine (DNS, TLS, firewall, dev server running) and that it responds within the timeout.",
             url,
             evidence: { error: res.error, redirectChain: res.redirectChain },
         });
@@ -64,17 +308,17 @@ export async function auditUrl(url, options = {}) {
     }
     await enrichPage(audit, options);
     return audit;
-}
+};
 /** Audit a single .html file from disk. */
-export async function auditFile(filePath, options = {}) {
-    const html = await fs.readFile(filePath, 'utf8');
-    const base = options.baseUrl ?? 'http://localhost/';
-    const url = new URL(`/${path.basename(filePath)}`, base.endsWith('/') ? base : `${base}/`).href;
-    return auditHtml(html, { url, source: 'file', target: filePath }, options);
-}
+export const auditFile = async (filePath, options = {}) => {
+    const html = await fs.readFile(filePath, "utf-8");
+    const base = options.baseUrl ?? "http://localhost/";
+    const url = new URL(`/${path.basename(filePath)}`, base.endsWith("/") ? base : `${base}/`).href;
+    return auditHtml(html, { url, source: "file", target: filePath }, options);
+};
 /** Crawl a site and audit every page plus site-level checks. */
-export async function auditSite(startUrl, options = {}) {
-    const fetchOpts = { ...(options.fetch ?? {}) };
+export const auditSite = async (startUrl, options = {}) => {
+    const fetchOpts = { ...options.fetch };
     fetchOpts.userAgent ??= DEFAULT_USER_AGENT;
     const internal = {
         maxPages: options.maxPages ?? DEFAULT_CRAWL.maxPages,
@@ -85,247 +329,143 @@ export async function auditSite(startUrl, options = {}) {
         includeSubdomains: options.includeSubdomains ?? false,
         checkExternalLinks: options.checkExternalLinks ?? false,
         maxLinkChecks: options.maxLinkChecks ?? DEFAULT_CRAWL.maxLinkChecks,
+        // oxlint-disable-next-line eslint/require-unicode-regexp -- the user's own patterns, in JavaScript's default syntax; the u flag would reject some of them
         includePatterns: (options.includePatterns ?? []).map((p) => new RegExp(p)),
+        // oxlint-disable-next-line eslint/require-unicode-regexp -- the user's own patterns, in JavaScript's default syntax; the u flag would reject some of them
         excludePatterns: (options.excludePatterns ?? []).map((p) => new RegExp(p)),
         fetch: fetchOpts,
         onProgress: options.onProgress,
     };
     const result = await crawlSite(startUrl, internal);
-    const site = await buildSiteAudit(result, 'crawl', startUrl, options);
+    const site = buildSiteAudit(result, "crawl", startUrl, options);
     // Render/Lighthouse are expensive: apply them to the start page only.
     const startPage = site.pages.find((p) => p.depth === 0) ?? site.pages[0];
     if (startPage && (options.render || options.lighthouse)) {
         await enrichPage(startPage, options);
         recomputeSite(site);
     }
-    return shapeSite(site, options);
-}
+    return applyPageDetail(site, options);
+};
 /** Audit a directory of built HTML files (dist/, out/, build/). */
-export async function auditDirectory(dir, options = {}) {
+export const auditDirectory = async (dir, options = {}) => {
     const result = await scanDirectory(dir, {
-        baseUrl: options.baseUrl ?? 'http://localhost/',
+        baseUrl: options.baseUrl ?? "http://localhost/",
         includeSubdomains: options.includeSubdomains ?? false,
         maxPages: options.maxPages ?? 500,
         userAgent: options.fetch?.userAgent,
     });
-    const site = await buildSiteAudit(result, 'directory', dir, options);
-    return shapeSite(site, options);
-}
+    const site = buildSiteAudit(result, "directory", dir, options);
+    return applyPageDetail(site, options);
+};
 /**
- * Auto-detect the target type: http(s) URL, directory, .html file, or "-" for stdin.
- * `crawl` forces a site crawl for URLs.
+ * What a target names: "-" for stdin, an http(s) URL, a bare host such as `example.com/page` or
+ * `localhost:3000`, a directory or a file.
  */
-export async function auditTarget(target, options = {}) {
-    if (target === '-' || options.stdinHtml !== undefined) {
-        const html = options.stdinHtml ?? (await readStdin());
-        return auditHtml(html, { url: options.baseUrl, source: 'html', target: 'stdin' }, options);
+export const resolveTarget = async (target) => {
+    if (target === "-") {
+        return { kind: "stdin" };
+    }
+    if (isHttpUrl(target)) {
+        return { kind: "url", url: target };
     }
-    if (isHttpUrl(target))
-        return options.crawl ? auditSite(target, options) : auditUrl(target, options);
-    if (/^localhost(:\d+)?(\/|$)/i.test(target) || /^[\w.-]+\.[a-z]{2,}(\/|$)/i.test(target)) {
-        const url = `http${/^localhost/i.test(target) ? '' : 's'}://${target}`;
-        return options.crawl ? auditSite(url, options) : auditUrl(url, options);
+    if (/^localhost(?::\d+)?(?:\/|$)/iu.test(target) ||
+        /^[\w.-]+\.[a-z]{2,}(?:\/|$)/iu.test(target)) {
+        return {
+            kind: "url",
+            url: `http${/^localhost/iu.test(target) ? "" : "s"}://${target}`,
+        };
     }
     const stat = await fs.stat(target).catch(() => null);
-    if (!stat)
+    if (!stat) {
         throw new Error(`Target "${target}" is not a URL, file or directory.`);
-    if (stat.isDirectory())
-        return auditDirectory(target, options);
-    return auditFile(target, options);
-}
-async function enrichPage(audit, options) {
-    const url = audit.response?.finalUrl ?? audit.url;
-    const extra = [];
-    if (options.render) {
-        options.onProgress?.({ phase: 'render', message: `Rendering ${url} with Playwright` });
-        try {
-            const rendered = await renderPage(url, { timeoutMs: Math.max(options.fetch?.timeoutMs ?? 0, 30_000), userAgent: options.fetch?.userAgent, headers: options.fetch?.headers });
-            const rawPage = extractPage(await rawHtmlFor(audit, options), { url, includeSubdomains: options.includeSubdomains });
-            const renderedPage = extractPage(rendered.html, { url: rendered.finalUrl, siteHost: new URL(url).hostname, includeSubdomains: options.includeSubdomains });
-            const { comparison, findings } = compareRender(rawPage, renderedPage, rendered.finalUrl, rendered.consoleErrors, audit.response);
-            audit.rendering = comparison;
-            extra.push(...findings);
+    }
+    return stat.isDirectory()
+        ? { kind: "directory", path: target }
+        : { kind: "file", path: target };
+};
+/** HTML piped to the process. */
+export const readStdin = async () => {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf-8");
+};
+/**
+ * Auto-detect the target type: http(s) URL, directory, .html file, or "-" for stdin.
+ * `crawl` forces a site crawl for URLs.
+ */
+export const auditTarget = async (target, options = {}) => {
+    const resolved = options.stdinHtml === undefined
+        ? await resolveTarget(target)
+        : { kind: "stdin" };
+    switch (resolved.kind) {
+        case "stdin": {
+            const html = options.stdinHtml ?? (await readStdin());
+            return auditHtml(html, { url: options.baseUrl, source: "html", target: "stdin" }, options);
         }
-        catch (err) {
-            extra.push(toolFinding('tool.render-unavailable', err instanceof RenderUnavailableError ? err.message : `Rendering failed: ${err.message}`, url));
+        case "url": {
+            return options.crawl
+                ? auditSite(resolved.url, options)
+                : auditUrl(resolved.url, options);
         }
-    }
-    if (options.lighthouse) {
-        options.onProgress?.({ phase: 'lighthouse', message: `Running Lighthouse (${options.formFactor ?? 'mobile'}) on ${url}` });
-        try {
-            const perf = await runLighthouse(url, { formFactor: options.formFactor ?? 'mobile', userAgent: options.fetch?.userAgent, headers: options.fetch?.headers });
-            audit.performance = perf;
-            extra.push(...performanceFindings(perf));
+        case "directory": {
+            return auditDirectory(resolved.path, options);
         }
-        catch (err) {
-            extra.push(toolFinding('tool.lighthouse-unavailable', err instanceof LighthouseUnavailableError ? err.message : `Lighthouse failed: ${err.message}`, url));
+        default: {
+            return auditFile(resolved.path, options);
         }
     }
-    if (extra.length) {
-        const filtered = options.includeInfo === false ? extra.filter((f) => f.severity !== 'info') : extra;
-        audit.findings = sortFindings([...audit.findings, ...filtered]);
-        audit.counts = countFindings(audit.findings);
-        audit.score = pageScore(audit.counts);
+};
+/** Keeps the first three items of every evidence list. */
+export const trimFinding = (f) => {
+    if (!f.evidence) {
+        return f;
     }
-}
-// The raw HTML is not kept on the audit (too large); re-fetch it for the render comparison.
-async function rawHtmlFor(audit, options) {
-    const res = await fetchPage(audit.response?.finalUrl ?? audit.url, options.fetch ?? {});
-    return res.body ?? '';
-}
-function toolFinding(rule, message, url) {
-    return {
-        rule,
-        severity: 'info',
-        category: 'tool',
-        message,
-        recommendation: 'Install the optional dependency (see message) or run without this option. The rest of the audit is complete.',
-        url,
-    };
-}
-async function buildSiteAudit(result, source, target, options) {
-    options.onProgress?.({ phase: 'rules', message: `Evaluating rules for ${result.records.length} pages` });
-    const thresholds = { ...DEFAULT_THRESHOLDS, ...(options.thresholds ?? {}) };
-    const pages = [];
-    for (const record of result.records) {
-        const audit = await auditRecord(record, source === 'directory' ? 'file' : 'url', options);
-        pages.push(audit);
+    const evidence = {};
+    for (const [k, v] of Object.entries(f.evidence)) {
+        evidence[k] = Array.isArray(v) ? v.slice(0, 3) : v;
     }
-    let siteFindings = runSiteRules({
-        startUrl: result.startUrl,
-        source,
-        pages: result.records,
-        linkChecks: result.linkChecks,
-        linkSources: result.linkSources,
-        externalChecks: result.externalChecks,
-        externalSources: result.externalSources,
-        robots: result.robots,
-        robotsAllows: result.robotsAllows,
-        blockedByRobots: result.blockedByRobots,
-        sitemaps: result.sitemaps,
-        probes: result.probes,
-        crawl: result.stats,
-        thresholds,
-        pathOnly: source === 'directory',
-        unlinkedPages: result.unlinkedPages,
-    });
-    const disabled = new Set(options.disableRules ?? []);
-    siteFindings = sortFindings(siteFindings.filter((f) => !disabled.has(f.rule)));
-    if (options.includeInfo === false)
-        siteFindings = siteFindings.filter((f) => f.severity !== 'info');
-    const site = {
-        schemaVersion: 1,
-        kind: 'site',
-        target,
-        source,
-        auditedAt: new Date().toISOString(),
-        crawl: result.stats,
-        robotsTxt: result.robots,
-        sitemaps: { ...result.sitemaps, urls: result.sitemaps.urls.slice(0, 200) },
-        pages: pages.sort((a, b) => (a.depth ?? 0) - (b.depth ?? 0) || a.score - b.score),
-        siteFindings,
-        issues: [],
-        counts: { error: 0, warning: 0, info: 0 },
-        score: 0,
+    return { ...f, evidence };
+};
+const trimPage = (p) => {
+    const { performance, rendering, ...rest } = p;
+    const out = {
+        ...rest,
+        summary: {
+            ...p.summary,
+            headings: p.summary.headings.slice(0, 10),
+            openGraph: {},
+        },
+        findings: p.findings.map(trimFinding),
     };
-    recomputeSite(site);
-    return site;
-}
-async function auditRecord(record, source, options) {
-    const thresholds = { ...DEFAULT_THRESHOLDS, ...(options.thresholds ?? {}) };
-    let findings = runPageRules({ page: record.page, source, response: record.response, keyword: options.keyword, thresholds, depth: record.depth }, { disable: new Set(options.disableRules ?? []) });
-    if (options.includeInfo === false)
-        findings = findings.filter((f) => f.severity !== 'info');
-    const audit = {
-        schemaVersion: 1,
-        kind: 'page',
-        target: record.file ?? record.requestedUrl,
-        url: record.file ?? record.url,
-        source,
-        auditedAt: new Date().toISOString(),
-        summary: buildSummary(record.page, record.response),
-        findings,
-        counts: countFindings(findings),
-        score: 0,
-        depth: record.depth,
-    };
-    if (record.response)
-        audit.response = record.response;
-    audit.score = pageScore(audit.counts);
-    return audit;
-}
-export function recomputeSite(site) {
-    const counts = countFindings(site.siteFindings);
-    for (const p of site.pages) {
-        counts.error += p.counts.error;
-        counts.warning += p.counts.warning;
-        counts.info += p.counts.info;
+    if (p.response) {
+        out.response = { ...p.response, headers: {} };
     }
-    site.counts = counts;
-    site.issues = rollupIssues(site.pages);
-    site.score = siteScore(site.pages, site.siteFindings);
-}
-export function rollupIssues(pages) {
-    const map = new Map();
-    for (const page of pages) {
-        const seenHere = new Set();
-        for (const f of page.findings) {
-            if (seenHere.has(f.rule))
-                continue;
-            seenHere.add(f.rule);
-            let entry = map.get(f.rule);
-            if (!entry) {
-                entry = { rule: f.rule, severity: f.severity, category: f.category, pages: 0, message: f.message, recommendation: f.recommendation, examples: [], urls: new Set() };
-                map.set(f.rule, entry);
-            }
-            entry.pages++;
-            entry.urls.add(page.url);
-        }
+    if (performance) {
+        out.performance = {
+            ...performance,
+            opportunities: performance.opportunities.slice(0, 5),
+            agenticBrowsingAudits: [],
+            failedSeoAudits: performance.failedSeoAudits.slice(0, 5),
+        };
     }
-    const rank = { error: 0, warning: 1, info: 2 };
-    return [...map.values()]
-        .sort((a, b) => rank[a.severity] - rank[b.severity] || b.pages - a.pages)
-        .map(({ urls, ...rest }) => ({ ...rest, examples: [...urls].slice(0, 10) }));
-}
-function shapeSite(site, options) {
-    if (options.pageDetail === 'summary') {
-        site.pages = site.pages.map((p) => ({ ...p, findings: [], summary: { ...p.summary, headings: [], openGraph: {} } }));
+    if (rendering) {
+        out.rendering = {
+            ...rendering,
+            consoleErrors: rendering.consoleErrors.slice(0, 3),
+        };
     }
-    return site;
-}
-async function readStdin() {
-    const chunks = [];
-    for await (const chunk of process.stdin)
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-    return Buffer.concat(chunks).toString('utf8');
-}
+    return out;
+};
 /** Drop bulky, low-value fields to save tokens when the result is consumed by an LLM. */
-export function compactAudit(audit) {
-    const trimFinding = (f) => {
-        if (!f.evidence)
-            return f;
-        const evidence = {};
-        for (const [k, v] of Object.entries(f.evidence))
-            evidence[k] = Array.isArray(v) ? v.slice(0, 3) : v;
-        return { ...f, evidence };
-    };
-    const trimPage = (p) => {
-        const { performance, rendering, ...rest } = p;
-        const out = {
-            ...rest,
-            summary: { ...p.summary, headings: p.summary.headings.slice(0, 10), openGraph: {} },
-            findings: p.findings.map(trimFinding),
-        };
-        if (p.response)
-            out.response = { ...p.response, headers: {} };
-        if (performance)
-            out.performance = { ...performance, opportunities: performance.opportunities.slice(0, 5), agenticBrowsingAudits: [], failedSeoAudits: performance.failedSeoAudits.slice(0, 5) };
-        if (rendering)
-            out.rendering = { ...rendering, consoleErrors: rendering.consoleErrors.slice(0, 3) };
-        return out;
-    };
-    if (audit.kind === 'page')
+export const compactAudit = (audit) => {
+    if (audit.kind === "page") {
+        // SAFETY: T is the page audit here (kind is "page"), and trimPage returns a page audit with
+        // every field it was given.
         return trimPage(audit);
+    }
+    // SAFETY: T is the site audit here; the spread keeps every field and only shortens lists.
     return {
         ...audit,
         robotsTxt: audit.robotsTxt ? { ...audit.robotsTxt, text: null } : null,
@@ -333,5 +473,5 @@ export function compactAudit(audit) {
         pages: audit.pages.map(trimPage),
         siteFindings: audit.siteFindings.map(trimFinding),
     };
-}
+};
 //# sourceMappingURL=audit.js.map