@aexol/spectral 0.9.41 → 0.9.43

package/dist/extensions/seo/analyzers/content.js

@@ -0,0 +1,174 @@
+/** Common filler phrases that add no information value. */
+const FILLER_PHRASES = [
+    "in today's fast-paced world",
+    "in the ever-evolving",
+    "it's important to note that",
+    "it's worth noting that",
+    "it goes without saying",
+    "needless to say",
+    "at the end of the day",
+    "when it comes to",
+    "in conclusion",
+    "in summary",
+    "as previously mentioned",
+    "as we all know",
+    "generally speaking",
+    "for the most part",
+    "in most cases",
+    "more often than not",
+    "it should be noted",
+    "keep in mind that",
+    "with that in mind",
+    "on the other hand",
+    "let's dive in",
+    "let's get started",
+    "without further ado",
+    "the bottom line is",
+    "you might be wondering",
+    "you're probably wondering",
+    "let's face it",
+    "here's the thing",
+    "long story short",
+    "make no mistake",
+    "the fact of the matter is",
+];
+/** Patterns characteristic of AI-generated text. */
+const AI_PATTERNS = [
+    "delve into",
+    "navigating the",
+    "in the realm of",
+    "unleash the power of",
+    "harness the power of",
+    "a testament to",
+    "a game-changer",
+    "paradigm shift",
+    "cutting-edge",
+    "revolutionary",
+    "groundbreaking",
+    "state-of-the-art",
+    "seamless integration",
+    "robust solution",
+    "comprehensive guide",
+    "ultimate guide",
+    "definitive guide",
+    "everything you need to know",
+    "you're not alone",
+    "picture this",
+    "imagine a world",
+    "fast-paced digital landscape",
+    "ever-changing landscape",
+    "in the world of",
+    "plays a crucial role",
+    "plays a vital role",
+    "plays a pivotal role",
+    "it's not just about",
+    "it's not just a",
+    "tapestry of",
+    "myriad of",
+    "plethora of",
+    "embark on a journey",
+    "unlock the potential",
+    "elevate your",
+    "transform your",
+    "redefine the way",
+];
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length > 0);
+}
+function countPatternMatches(text, patterns) {
+    const lower = text.toLowerCase();
+    let count = 0;
+    const matches = [];
+    for (const pattern of patterns) {
+        const regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
+        const found = lower.match(regex);
+        if (found) {
+            count += found.length;
+            matches.push(...found);
+        }
+    }
+    return { count, matches };
+}
+function calculateRepetition(tokens) {
+    if (tokens.length === 0)
+        return 0;
+    // Count trigram repetitions.
+    const trigrams = new Map();
+    for (let i = 0; i < tokens.length - 2; i++) {
+        const trigram = `${tokens[i]} ${tokens[i + 1]} ${tokens[i + 2]}`;
+        trigrams.set(trigram, (trigrams.get(trigram) ?? 0) + 1);
+    }
+    let repeated = 0;
+    for (const count of trigrams.values()) {
+        if (count > 1)
+            repeated += count - 1;
+    }
+    const maxRepetition = trigrams.size > 0 ? repeated / trigrams.size : 0;
+    return Math.min(100, Math.round(maxRepetition * 100));
+}
+function calculateInformationDensity(text, tokens) {
+    if (tokens.length === 0)
+        return 0;
+    // Count entities (capitalized words) and numbers.
+    const entities = (text.match(/\b[A-Z][a-z]+\b/g) ?? []).length;
+    const numbers = (text.match(/\b\d+([.,]\d+)?\b/g) ?? []).length;
+    const informative = entities + numbers;
+    // Density = informative tokens / total tokens, scaled 0-100.
+    return Math.min(100, Math.round((informative / tokens.length) * 1000));
+}
+/**
+ * Analyze content quality of a text string.
+ *
+ * All scores are 0-100 where higher is better (except filler and AI pattern
+ * scores, where higher means MORE problematic content).
+ */
+export function analyzeContentQuality(text, url) {
+    const tokens = tokenize(text);
+    const wordCount = text.split(/\s+/).filter(Boolean).length;
+    const uniqueTokens = new Set(tokens).size;
+    // Filler phrase detection.
+    const filler = countPatternMatches(text, FILLER_PHRASES);
+    const fillerScore = Math.min(100, Math.round((filler.count / Math.max(1, wordCount / 100)) * 20));
+    // AI pattern detection.
+    const aiPatterns = countPatternMatches(text, AI_PATTERNS);
+    const aiPatternScore = Math.min(100, Math.round((aiPatterns.count / Math.max(1, wordCount / 100)) * 20));
+    // Information density (higher is better).
+    const informationDensity = calculateInformationDensity(text, tokens);
+    // Repetition score (higher means MORE repetition, worse).
+    const repetitionScore = calculateRepetition(tokens);
+    // Overall quality: start at 100, subtract penalties.
+    let overall = 100;
+    overall -= fillerScore * 0.3;
+    overall -= aiPatternScore * 0.3;
+    overall -= repetitionScore * 0.2;
+    overall -= Math.max(0, 30 - informationDensity) * 0.2; // penalize low density
+    overall = Math.max(0, Math.min(100, Math.round(overall)));
+    const flags = [];
+    if (fillerScore > 30)
+        flags.push("high-filler-density");
+    if (aiPatternScore > 30)
+        flags.push("likely-ai-generated");
+    if (repetitionScore > 40)
+        flags.push("excessive-repetition");
+    if (informationDensity < 10)
+        flags.push("low-information-density");
+    if (wordCount < 300)
+        flags.push("thin-content");
+    return {
+        url,
+        wordCount,
+        tokens: tokens.length,
+        uniqueTokens,
+        fillerScore,
+        aiPatternScore,
+        informationDensity,
+        repetitionScore,
+        overallQuality: overall,
+        flags,
+        fillerMatches: filler.matches,
+        aiPatternMatches: aiPatterns.matches,
+    };
+}

package/dist/extensions/seo/analyzers/drift.d.ts

@@ -0,0 +1,13 @@
+import type { DriftBaseline, DriftCompareResult } from "../types.js";
+import type { SeoConfig } from "../config.js";
+/** Close the database connection (called on session shutdown). */
+export declare function closeDriftDb(): void;
+/** Capture a baseline snapshot of a page. */
+export declare function captureBaseline(url: string, config: SeoConfig): Promise<DriftBaseline>;
+/** Get a baseline by ID or the latest baseline for a URL. */
+export declare function getBaseline(url: string, config: SeoConfig, baselineId?: number): DriftBaseline | null;
+/** Compare current page state against a baseline. */
+export declare function compareBaseline(url: string, config: SeoConfig, baselineId?: number): Promise<DriftCompareResult>;
+/** Get baseline history for a URL. */
+export declare function getBaselineHistory(url: string, config: SeoConfig, limit?: number): DriftBaseline[];
+//# sourceMappingURL=drift.d.ts.map

package/dist/extensions/seo/analyzers/drift.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drift.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/drift.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAqC9C,kEAAkE;AAClE,wBAAgB,YAAY,IAAI,IAAI,CASnC;AAMD,6CAA6C;AAC7C,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,aAAa,CAAC,CAwDxB;AAED,6DAA6D;AAC7D,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAWrG;AAuBD,qDAAqD;AACrD,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,SAAS,EACjB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,kBAAkB,CAAC,CAuE7B;AAED,sCAAsC;AACtC,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,SAAK,GAAG,aAAa,EAAE,CAK9F"}

package/dist/extensions/seo/analyzers/drift.js

@@ -0,0 +1,204 @@
+/**
+ * SEO drift monitoring — baseline capture and comparison.
+ *
+ * Ported from the Python `drift_baseline.py` and `drift_compare.py` in
+ * claude-seo. Stores snapshots in a local SQLite database and compares
+ * current page state against a known-good baseline.
+ */
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { createHash } from "node:crypto";
+import Database from "better-sqlite3";
+import { parsePage } from "../utils/parser.js";
+import { fetchPage } from "../utils/fetcher.js";
+import { normalizeUrl, urlHash } from "../utils/url-safety.js";
+let dbInstance = null;
+function getDb(config) {
+    if (dbInstance)
+        return dbInstance;
+    mkdirSync(dirname(config.dbPath), { recursive: true });
+    dbInstance = new Database(config.dbPath);
+    dbInstance.pragma("journal_mode = WAL");
+    dbInstance.exec(`
+    CREATE TABLE IF NOT EXISTS baselines (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      url TEXT NOT NULL,
+      url_hash TEXT NOT NULL,
+      timestamp TEXT NOT NULL,
+      title TEXT,
+      meta_description TEXT,
+      canonical TEXT,
+      robots TEXT,
+      h1 TEXT,
+      h2_json TEXT,
+      h3_json TEXT,
+      schema_json TEXT,
+      og_json TEXT,
+      html_hash TEXT,
+      schema_hash TEXT,
+      status_code INTEGER
+    );
+    CREATE INDEX IF NOT EXISTS idx_url_hash ON baselines(url_hash);
+  `);
+    return dbInstance;
+}
+/** Close the database connection (called on session shutdown). */
+export function closeDriftDb() {
+    if (dbInstance) {
+        try {
+            dbInstance.close();
+        }
+        catch {
+            // ignore
+        }
+        dbInstance = null;
+    }
+}
+function hashContent(content) {
+    return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+/** Capture a baseline snapshot of a page. */
+export async function captureBaseline(url, config) {
+    const fetchResult = await fetchPage(url, config);
+    const pageData = parsePage(fetchResult.content, fetchResult.finalUrl);
+    const hash = urlHash(url);
+    const timestamp = new Date().toISOString();
+    const h2Json = JSON.stringify(pageData.headings.filter((h) => h.level === 2).map((h) => h.text));
+    const h3Json = JSON.stringify(pageData.headings.filter((h) => h.level === 3).map((h) => h.text));
+    const schemaJson = JSON.stringify(pageData.schemaBlocks.map((s) => ({ type: s.type, format: s.format })));
+    const ogJson = JSON.stringify(pageData.ogTags);
+    const htmlHash = hashContent(fetchResult.content);
+    const schemaHash = hashContent(schemaJson);
+    const db = getDb(config);
+    const stmt = db.prepare(`
+    INSERT INTO baselines
+      (url, url_hash, timestamp, title, meta_description, canonical, robots,
+       h1, h2_json, h3_json, schema_json, og_json, html_hash, schema_hash, status_code)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `);
+    const info = stmt.run(normalizeUrl(url), hash, timestamp, pageData.title, pageData.metaDescription, pageData.canonical, pageData.metaRobots, pageData.headings.find((h) => h.level === 1)?.text ?? null, h2Json, h3Json, schemaJson, ogJson, htmlHash, schemaHash, fetchResult.statusCode);
+    return {
+        id: Number(info.lastInsertRowid),
+        url: normalizeUrl(url),
+        urlHash: hash,
+        timestamp,
+        title: pageData.title,
+        metaDescription: pageData.metaDescription,
+        canonical: pageData.canonical,
+        robots: pageData.metaRobots,
+        h1: pageData.headings.find((h) => h.level === 1)?.text ?? null,
+        h2Json,
+        h3Json,
+        schemaJson,
+        ogJson,
+        htmlHash,
+        schemaHash,
+        statusCode: fetchResult.statusCode,
+    };
+}
+/** Get a baseline by ID or the latest baseline for a URL. */
+export function getBaseline(url, config, baselineId) {
+    const db = getDb(config);
+    const hash = urlHash(url);
+    if (baselineId !== undefined) {
+        const row = db.prepare("SELECT * FROM baselines WHERE id = ?").get(baselineId);
+        return row ? rowToBaseline(row) : null;
+    }
+    const row = db.prepare("SELECT * FROM baselines WHERE url_hash = ? ORDER BY id DESC LIMIT 1").get(hash);
+    return row ? rowToBaseline(row) : null;
+}
+function rowToBaseline(row) {
+    return {
+        id: row.id,
+        url: row.url,
+        urlHash: row.url_hash,
+        timestamp: row.timestamp,
+        title: row.title ?? null,
+        metaDescription: row.meta_description ?? null,
+        canonical: row.canonical ?? null,
+        robots: row.robots ?? null,
+        h1: row.h1 ?? null,
+        h2Json: row.h2_json ?? "[]",
+        h3Json: row.h3_json ?? "[]",
+        schemaJson: row.schema_json ?? "[]",
+        ogJson: row.og_json ?? "[]",
+        htmlHash: row.html_hash ?? "",
+        schemaHash: row.schema_hash ?? "",
+        statusCode: row.status_code ?? 0,
+    };
+}
+/** Compare current page state against a baseline. */
+export async function compareBaseline(url, config, baselineId) {
+    const baseline = getBaseline(url, config, baselineId);
+    if (!baseline) {
+        throw new Error(`No baseline found for ${url}${baselineId ? ` (id=${baselineId})` : ""}.`);
+    }
+    const fetchResult = await fetchPage(url, config);
+    const pageData = parsePage(fetchResult.content, fetchResult.finalUrl);
+    const changedFields = [];
+    const details = {};
+    const comparisons = [
+        { field: "title", before: baseline.title, after: pageData.title },
+        { field: "metaDescription", before: baseline.metaDescription, after: pageData.metaDescription },
+        { field: "canonical", before: baseline.canonical, after: pageData.canonical },
+        { field: "robots", before: baseline.robots, after: pageData.metaRobots },
+        { field: "h1", before: baseline.h1, after: pageData.headings.find((h) => h.level === 1)?.text ?? null },
+        {
+            field: "h2",
+            before: JSON.parse(baseline.h2Json),
+            after: pageData.headings.filter((h) => h.level === 2).map((h) => h.text),
+        },
+        {
+            field: "h3",
+            before: JSON.parse(baseline.h3Json),
+            after: pageData.headings.filter((h) => h.level === 3).map((h) => h.text),
+        },
+        {
+            field: "schema",
+            before: JSON.parse(baseline.schemaJson),
+            after: pageData.schemaBlocks.map((s) => ({ type: s.type, format: s.format })),
+        },
+        { field: "statusCode", before: baseline.statusCode, after: fetchResult.statusCode },
+    ];
+    for (const cmp of comparisons) {
+        const beforeStr = JSON.stringify(cmp.before);
+        const afterStr = JSON.stringify(cmp.after);
+        if (beforeStr !== afterStr) {
+            changedFields.push(cmp.field);
+            details[cmp.field] = { before: cmp.before, after: cmp.after };
+        }
+    }
+    // HTML hash comparison.
+    const currentHtmlHash = hashContent(fetchResult.content);
+    if (currentHtmlHash !== baseline.htmlHash) {
+        changedFields.push("htmlHash");
+        details.htmlHash = { before: baseline.htmlHash, after: currentHtmlHash };
+    }
+    // Determine severity.
+    let severity = "none";
+    if (changedFields.includes("title") || changedFields.includes("canonical") || changedFields.includes("statusCode")) {
+        severity = "high";
+    }
+    else if (changedFields.includes("metaDescription") || changedFields.includes("h1") || changedFields.includes("schema")) {
+        severity = "medium";
+    }
+    else if (changedFields.length > 0) {
+        severity = "low";
+    }
+    return {
+        url: fetchResult.finalUrl,
+        baselineId: baseline.id,
+        baselineTimestamp: baseline.timestamp,
+        comparedAt: new Date().toISOString(),
+        changedFields,
+        details,
+        severity,
+    };
+}
+/** Get baseline history for a URL. */
+export function getBaselineHistory(url, config, limit = 20) {
+    const db = getDb(config);
+    const hash = urlHash(url);
+    const rows = db.prepare("SELECT * FROM baselines WHERE url_hash = ? ORDER BY id DESC LIMIT ?").all(hash, limit);
+    return rows.map(rowToBaseline);
+}

package/dist/extensions/seo/analyzers/images.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Image SEO analyzer.
+ *
+ * Extracts image data from parsed HTML and flags common SEO issues:
+ * missing alt text, missing dimensions, lazy-loading method, and modern
+ * format usage.
+ */
+import type { ImageAuditResult } from "../types.js";
+export declare function auditImages(html: string, url?: string): ImageAuditResult;
+//# sourceMappingURL=images.d.ts.map

package/dist/extensions/seo/analyzers/images.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"images.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/images.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAuB,MAAM,aAAa,CAAC;AAiBzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAqCxE"}

package/dist/extensions/seo/analyzers/images.js

@@ -0,0 +1,49 @@
+import { parsePage } from "../utils/parser.js";
+const MODERN_FORMATS = [".webp", ".avif", ".jxl"];
+function getExtension(src) {
+    try {
+        const url = new URL(src);
+        const path = url.pathname;
+        const dotIdx = path.lastIndexOf(".");
+        return dotIdx >= 0 ? path.slice(dotIdx).toLowerCase() : "";
+    }
+    catch {
+        const dotIdx = src.lastIndexOf(".");
+        return dotIdx >= 0 ? src.slice(dotIdx).toLowerCase() : "";
+    }
+}
+export function auditImages(html, url) {
+    const pageData = parsePage(html, url);
+    const images = pageData.images;
+    let missingAlt = 0;
+    let missingDimensions = 0;
+    const lazyCounts = { native: 0, dataSrc: 0, dataLazy: 0, none: 0 };
+    let modernFormats = 0;
+    const oversized = [];
+    for (const img of images) {
+        if (!img.alt)
+            missingAlt++;
+        if (!img.width || !img.height)
+            missingDimensions++;
+        lazyCounts[img.lazyMethod]++;
+        const ext = getExtension(img.src);
+        if (MODERN_FORMATS.includes(ext))
+            modernFormats++;
+        // Flag potential oversized images (large numeric dimensions).
+        const w = img.width ? Number.parseInt(img.width, 10) : 0;
+        const h = img.height ? Number.parseInt(img.height, 10) : 0;
+        if (w > 2000 || h > 2000) {
+            oversized.push(img.src);
+        }
+    }
+    return {
+        url: url ?? pageData.url,
+        totalImages: images.length,
+        missingAlt,
+        missingDimensions,
+        lazyLoading: lazyCounts,
+        modernFormats,
+        oversized,
+        images,
+    };
+}

package/dist/extensions/seo/analyzers/parasite.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Parasite-SEO risk scanner.
+ *
+ * Ported from the Python `parasite_risk.py` in claude-seo. Scans a set of
+ * URLs from one host, classifies content by subfolder, and flags section-level
+ * parasite-SEO risk via third-party byline patterns, commercial-intent
+ * patterns, and affiliate link markers.
+ */
+import type { ParasiteRiskResult } from "../types.js";
+import type { SeoConfig } from "../config.js";
+/**
+ * Scan a list of URLs from one host for parasite-SEO risk.
+ *
+ * Each URL is fetched and audited individually. Results are grouped by
+ * subfolder (first path segment) and scored.
+ */
+export declare function scanParasiteRisk(urls: string[], config: SeoConfig): Promise<ParasiteRiskResult>;
+//# sourceMappingURL=parasite.d.ts.map

package/dist/extensions/seo/analyzers/parasite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parasite.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/parasite.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAqB,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAyE9C;;;;;GAKG;AACH,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,kBAAkB,CAAC,CAuE7B"}

package/dist/extensions/seo/analyzers/parasite.js

@@ -0,0 +1,142 @@
+import { fetchPage } from "../utils/fetcher.js";
+import { parsePage } from "../utils/parser.js";
+const THIRD_PARTY_BYLINE_PATTERNS = [
+    /\bPartner\s+Content\b/gi,
+    /\bSponsored\s+Content\b/gi,
+    /\bSponsored\s+by\b/gi,
+    /\bBrand\s+Studio\b/gi,
+    /\bIn\s+Partnership\s+With\b/gi,
+    /\bAdvertisement\b/gi,
+    /\bAdvertorial\b/gi,
+    /\bPaid\s+Post\b/gi,
+    /\bPromoted\b/gi,
+    /\bPaid\s+Content\b/gi,
+];
+const COMMERCE_PATTERNS = [
+    /\bBuy\s+Now\b/gi,
+    /\bShop\s+Now\b/gi,
+    /\bAdd\s+to\s+Cart\b/gi,
+    /\bCompare\s+Prices\b/gi,
+    /\bBest\s+\w+\s+Deals?\b/gi,
+    /\bPromo\s+Code\b/gi,
+    /\bCoupon\b/gi,
+    /\bDiscount\s+Code\b/gi,
+    /\bAffiliate\s+Disclosure\b/gi,
+];
+const AFFILIATE_LINK_RE = /\b(?:tag=|aff_id=|affid=|partnerid=|ref_=|utm_source=|utm_campaign=)/gi;
+function getSubfolder(url) {
+    try {
+        const parsed = new URL(url);
+        const path = parsed.pathname || "/";
+        const parts = path.split("/").filter(Boolean);
+        return parts.length > 0 ? `/${parts[0]}/` : "/";
+    }
+    catch {
+        return "/";
+    }
+}
+function auditPageHtml(html, url) {
+    let thirdPartyHits = 0;
+    let commerceHits = 0;
+    for (const pattern of THIRD_PARTY_BYLINE_PATTERNS) {
+        const matches = html.match(pattern);
+        if (matches)
+            thirdPartyHits += matches.length;
+    }
+    for (const pattern of COMMERCE_PATTERNS) {
+        const matches = html.match(pattern);
+        if (matches)
+            commerceHits += matches.length;
+    }
+    // Count affiliate links from parsed links.
+    const pageData = parsePage(html, url);
+    let affiliateLinkHits = 0;
+    for (const link of pageData.links) {
+        if (AFFILIATE_LINK_RE.test(link.href)) {
+            affiliateLinkHits++;
+        }
+    }
+    return {
+        url,
+        thirdPartyHits,
+        commerceHits,
+        affiliateLinkHits,
+    };
+}
+/**
+ * Scan a list of URLs from one host for parasite-SEO risk.
+ *
+ * Each URL is fetched and audited individually. Results are grouped by
+ * subfolder (first path segment) and scored.
+ */
+export async function scanParasiteRisk(urls, config) {
+    // Determine host from first URL.
+    let host = "";
+    try {
+        host = new URL(urls[0]).hostname;
+    }
+    catch {
+        host = "unknown";
+    }
+    const audits = [];
+    for (const url of urls) {
+        try {
+            const result = await fetchPage(url, config);
+            if (result.statusCode === 200 && result.content) {
+                audits.push(auditPageHtml(result.content, result.finalUrl));
+            }
+            else {
+                audits.push({ url, thirdPartyHits: 0, commerceHits: 0, affiliateLinkHits: 0 });
+            }
+        }
+        catch {
+            audits.push({ url, thirdPartyHits: 0, commerceHits: 0, affiliateLinkHits: 0 });
+        }
+    }
+    // Group by subfolder.
+    const bySection = new Map();
+    for (const audit of audits) {
+        const section = getSubfolder(audit.url);
+        if (!bySection.has(section)) {
+            bySection.set(section, []);
+        }
+        bySection.get(section).push(audit);
+    }
+    const sections = [...bySection.entries()].map(([section, pages]) => {
+        const n = pages.length;
+        const thirdPartyRate = pages.reduce((sum, p) => sum + p.thirdPartyHits, 0) / n;
+        const commerceRate = pages.reduce((sum, p) => sum + p.commerceHits, 0) / n;
+        const affiliateRate = pages.reduce((sum, p) => sum + p.affiliateLinkHits, 0) / n;
+        const flags = [];
+        let risk = "low";
+        if (thirdPartyRate >= 1.0)
+            flags.push("third-party-authorship-density");
+        if (commerceRate >= 2.0)
+            flags.push("commercial-intent-skew");
+        if (affiliateRate >= 3.0)
+            flags.push("affiliate-density");
+        if (flags.includes("third-party-authorship-density")) {
+            risk = "high";
+        }
+        else if (flags.includes("commercial-intent-skew") && flags.includes("affiliate-density")) {
+            risk = "high";
+        }
+        else if (flags.length > 0) {
+            risk = "medium";
+        }
+        return {
+            section,
+            pageCount: n,
+            thirdPartyHitsPerPage: Math.round(thirdPartyRate * 100) / 100,
+            commerceHitsPerPage: Math.round(commerceRate * 100) / 100,
+            affiliateLinkHitsPerPage: Math.round(affiliateRate * 100) / 100,
+            flags,
+            risk,
+        };
+    });
+    return {
+        host,
+        totalPages: urls.length,
+        sections,
+    };
+}

package/dist/extensions/seo/analyzers/preload.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Preload / Speculation Rules / bfcache analyzer.
+ *
+ * Ported from the Python `preload_check.py` in claude-seo. Audits static HTML
+ * and response headers for the four preload mechanisms Google rewards in
+ * 2025-2026: speculation rules, preload hints, deprecated prerender, and
+ * bfcache signals.
+ */
+import type { PreloadAuditResult } from "../types.js";
+import type { FetchResult } from "../types.js";
+export declare function auditPreload(fetchResult: FetchResult): PreloadAuditResult;
+//# sourceMappingURL=preload.d.ts.map

package/dist/extensions/seo/analyzers/preload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preload.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/preload.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAsB/C,wBAAgB,YAAY,CAAC,WAAW,EAAE,WAAW,GAAG,kBAAkB,CAsGzE"}