@aexol/spectral 0.9.42 → 0.9.44

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/keywords.d.ts

@@ -0,0 +1,9 @@
+import type { KeywordAnalysisResult } from "../types.js";
+export declare function analyzeKeywords(text: string, url?: string): KeywordAnalysisResult;
+export declare function analyzeKeywordDensity(text: string, targetKeywords: string[]): Array<{
+    keyword: string;
+    count: number;
+    density: number;
+    verdict: string;
+}>;
+//# sourceMappingURL=keywords.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"keywords.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/keywords.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAe,MAAM,aAAa,CAAC;AA4GtE,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,qBAAqB,CAgEjF;AAeD,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,MAAM,EAAE,GACvB,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAkB7E"}

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

@@ -0,0 +1,183 @@
+const STOP_WORDS = new Set([
+    "a", "an", "the", "and", "or", "but", "in", "on", "at", "to", "for",
+    "of", "with", "by", "from", "up", "about", "into", "through", "during",
+    "before", "after", "above", "below", "between", "out", "off", "over",
+    "under", "again", "further", "then", "once", "here", "there", "when",
+    "where", "why", "how", "all", "both", "each", "few", "more", "most",
+    "other", "some", "such", "no", "nor", "not", "only", "own", "same",
+    "so", "than", "too", "very", "s", "t", "can", "will", "just", "don",
+    "should", "now", "is", "are", "was", "were", "be", "been", "being",
+    "have", "has", "had", "having", "do", "does", "did", "doing", "it",
+    "its", "this", "that", "these", "those", "i", "me", "my", "we", "our",
+    "you", "your", "he", "she", "they", "them", "their", "what", "which",
+    "who", "whom", "would", "could", "may", "might", "shall", "must",
+]);
+const COMMERCIAL_INTENT_WORDS = new Set([
+    "buy", "price", "pricing", "cost", "cheap", "discount", "coupon", "deal",
+    "best", "top", "review", "comparison", "vs", "versus", "alternative",
+    "sale", "shop", "order", "purchase", "subscription", "plan", "premium",
+    "pro", "enterprise", "trial", "demo", "free", "signup", "register",
+]);
+const TRANSACTIONAL_INTENT_WORDS = new Set([
+    "download", "install", "sign up", "register", "subscribe", "join",
+    "try", "start", "get started", "book", "reserve", "schedule",
+]);
+const INFORMATIONAL_INTENT_WORDS = new Set([
+    "what is", "how to", "guide", "tutorial", "learn", "definition",
+    "meaning", "example", "documentation", "docs", "reference", "api",
+    "specification", "language", "framework", "concept",
+]);
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter((t) => t.length > 1 && !STOP_WORDS.has(t));
+}
+function calculateTF(tokens) {
+    const tf = new Map();
+    for (const token of tokens) {
+        tf.set(token, (tf.get(token) ?? 0) + 1);
+    }
+    return tf;
+}
+function extractNgrams(tokens, n) {
+    const ngrams = new Map();
+    for (let i = 0; i <= tokens.length - n; i++) {
+        const ngram = tokens.slice(i, i + n).join(" ");
+        ngrams.set(ngram, (ngrams.get(ngram) ?? 0) + 1);
+    }
+    return ngrams;
+}
+function calculateKeywordDensity(tf, totalTokens) {
+    const density = new Map();
+    for (const [word, count] of tf) {
+        density.set(word, Number(((count / totalTokens) * 100).toFixed(2)));
+    }
+    return density;
+}
+function classifyIntent(text) {
+    const lower = text.toLowerCase();
+    let informational = 0;
+    let commercial = 0;
+    let transactional = 0;
+    for (const word of INFORMATIONAL_INTENT_WORDS) {
+        const regex = new RegExp(`\\b${word.replace(/\s+/g, "\\s+")}\\b`, "gi");
+        const matches = lower.match(regex);
+        if (matches)
+            informational += matches.length;
+    }
+    for (const word of COMMERCIAL_INTENT_WORDS) {
+        const regex = new RegExp(`\\b${word.replace(/\s+/g, "\\s+")}\\b`, "gi");
+        const matches = lower.match(regex);
+        if (matches)
+            commercial += matches.length;
+    }
+    for (const word of TRANSACTIONAL_INTENT_WORDS) {
+        const regex = new RegExp(`\\b${word.replace(/\s+/g, "\\s+")}\\b`, "gi");
+        const matches = lower.match(regex);
+        if (matches)
+            transactional += matches.length;
+    }
+    const total = informational + commercial + transactional;
+    if (total === 0)
+        return { intent: "informational", confidence: 0.3 };
+    const infPct = informational / total;
+    const comPct = commercial / total;
+    const transPct = transactional / total;
+    if (infPct > 0.5)
+        return { intent: "informational", confidence: infPct };
+    if (transPct > 0.4)
+        return { intent: "transactional", confidence: transPct };
+    if (comPct > 0.4)
+        return { intent: "commercial", confidence: comPct };
+    return { intent: "mixed", confidence: Math.max(infPct, comPct, transPct) };
+}
+export function analyzeKeywords(text, url) {
+    const tokens = tokenize(text);
+    const totalWords = text.split(/\s+/).filter(Boolean).length;
+    const tf = calculateTF(tokens);
+    const density = calculateKeywordDensity(tf, tokens.length);
+    // TF-IDF approximation (single-document IDF based on distribution)
+    const maxCount = Math.max(1, ...tf.values());
+    const keywords = [];
+    const seen = new Set();
+    for (const [word, count] of tf) {
+        if (seen.has(word))
+            continue;
+        seen.add(word);
+        // TF-IDF: normalize count and apply log-weight for rarity
+        const tfidf = (count / maxCount) * Math.log(tokens.length / count);
+        const variants = findVariants(word, tokens);
+        if (count >= 2 || variants.length > 1) {
+            keywords.push({
+                keyword: word,
+                count,
+                density: density.get(word) ?? 0,
+                tfidf: Number(tfidf.toFixed(3)),
+                variants: variants.filter((v) => v !== word).slice(0, 5),
+            });
+        }
+    }
+    // Sort by TF-IDF score
+    keywords.sort((a, b) => b.tfidf - a.tfidf);
+    // Extract bigrams and trigrams
+    const bigrams = extractNgrams(tokens, 2);
+    const trigrams = extractNgrams(tokens, 3);
+    const topNgrams = [];
+    for (const [ngram, count] of [...bigrams, ...trigrams]) {
+        if (count >= 2)
+            topNgrams.push({ ngram, count });
+    }
+    topNgrams.sort((a, b) => b.count - a.count);
+    // Intent classification
+    const { intent, confidence } = classifyIntent(text);
+    // Keyword stuffing detection
+    const keywordStuffingFlags = [];
+    for (const kw of keywords) {
+        if (kw.density > 3.0) {
+            keywordStuffingFlags.push(`"${kw.keyword}" at ${kw.density}% density — exceeds 3% threshold (possible keyword stuffing)`);
+        }
+    }
+    return {
+        url: url ?? "",
+        totalWords,
+        keywords: keywords.slice(0, 30),
+        topNgrams: topNgrams.slice(0, 15),
+        searchIntent: intent,
+        intentConfidence: confidence,
+        keywordStuffingFlags,
+    };
+}
+function findVariants(baseWord, tokens) {
+    const variants = new Set();
+    const lower = baseWord.toLowerCase();
+    for (const token of tokens) {
+        if (token === lower)
+            continue;
+        // Simple stemming: check if token starts with or contains the base word
+        if (token.startsWith(lower) || lower.startsWith(token)) {
+            variants.add(token);
+        }
+    }
+    return [...variants];
+}
+export function analyzeKeywordDensity(text, targetKeywords) {
+    const tokens = tokenize(text);
+    const lower = text.toLowerCase();
+    return targetKeywords.map((kw) => {
+        const regex = new RegExp(`\\b${kw.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "gi");
+        const matches = lower.match(regex);
+        const count = matches ? matches.length : 0;
+        const density = tokens.length > 0 ? Number(((count / tokens.length) * 100).toFixed(2)) : 0;
+        let verdict;
+        if (density < 0.5)
+            verdict = "too low — consider adding more mentions";
+        else if (density > 3.0)
+            verdict = "too high — possible keyword stuffing";
+        else if (density > 1.5)
+            verdict = "optimal";
+        else
+            verdict = "acceptable but could be improved";
+        return { keyword: kw, count, density, verdict };
+    });
+}

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/performance.d.ts

@@ -0,0 +1,6 @@
+import type { PerformanceResult, PageWeightResult, RenderBlockingResult, FontAuditResult, FetchResult } from "../types.js";
+export declare function calculatePerformanceFromFetch(fetchResult: FetchResult, url: string): PerformanceResult;
+export declare function analyzePageWeight(fetchResult: FetchResult, url: string): PageWeightResult;
+export declare function analyzeRenderBlocking(fetchResult: FetchResult, url: string): RenderBlockingResult;
+export declare function analyzeFonts(fetchResult: FetchResult, url: string): FontAuditResult;
+//# sourceMappingURL=performance.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"performance.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/performance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAS3H,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,WAAW,EACxB,GAAG,EAAE,MAAM,GACV,iBAAiB,CA0EnB;AAiCD,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,gBAAgB,CA6CzF;AAED,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAgDjG;AAED,wBAAgB,YAAY,CAAC,WAAW,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,eAAe,CAyEnF"}