@aexol/spectral 0.9.126 → 0.9.128

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

@@ -12,7 +12,9 @@ const AI_CRAWLER_TOKENS = [
 function parseRobotsTxt(content) {
     const lines = content.split("\n").map((l) => l.trim());
     let sitemapDeclared = false;
+    const sitemapUrls = [];
     const aiCrawlerRules = [];
+    const disallowRules = [];
     let currentUserAgents = [];
     for (const line of lines) {
         if (!line || line.startsWith("#"))
@@ -30,17 +32,22 @@ function parseRobotsTxt(content) {
                 if (AI_CRAWLER_TOKENS.includes(ua)) {
                     aiCrawlerRules.push(`${ua}: ${key} ${value}`);
                 }
+                if (ua === "*" && key === "disallow") {
+                    disallowRules.push(value);
+                }
             }
         }
         else if (key === "sitemap") {
             sitemapDeclared = true;
+            if (value.startsWith("http://") || value.startsWith("https://")) {
+                sitemapUrls.push(value);
+            }
         }
-        // Reset user-agents when we hit a non-user-agent line after a group.
         if (key !== "user-agent") {
             currentUserAgents = [];
         }
     }
-    return { sitemapDeclared, aiCrawlerRules };
+    return { sitemapDeclared, sitemapUrls, aiCrawlerRules, disallowRules };
 }
 const SECURITY_HEADERS = [
     "content-security-policy",
@@ -53,24 +60,26 @@ const SECURITY_HEADERS = [
 export async function auditTechnical(url, config, pageData, fetchResult) {
     const issues = [];
     const categoryScores = {};
-    // Fetch the page if not provided.
     if (!fetchResult) {
         fetchResult = await fetchPage(url, config);
     }
     if (!pageData) {
         pageData = parsePage(fetchResult.content, fetchResult.finalUrl);
     }
-    // Fetch robots.txt.
     let robotsResult = null;
     try {
         robotsResult = await fetchRobotsTxt(url, config);
     }
     catch {
-        // ignore
+        // robots.txt fetch failed gracefully
     }
     const robotsContent = robotsResult?.statusCode === 200 ? robotsResult.content : "";
-    const robotsParsed = robotsContent ? parseRobotsTxt(robotsContent) : { sitemapDeclared: false, aiCrawlerRules: [] };
-    // --- Crawlability ---
+    const robotsParsed = robotsContent
+        ? parseRobotsTxt(robotsContent)
+        : { sitemapDeclared: false, aiCrawlerRules: [], disallowRules: [], sitemapUrls: [] };
+    // ============================================================
+    // CRAWLABILITY
+    // ============================================================
     let crawlScore = 100;
     if (robotsResult?.statusCode !== 200) {
         crawlScore -= 30;
@@ -92,9 +101,26 @@ export async function auditTechnical(url, config, pageData, fetchResult) {
             recommendation: "Add 'Sitemap: https://example.com/sitemap.xml' to robots.txt.",
         });
     }
+    // J. Blocked resources — significant disallow rules for User-agent: *
+    if (robotsParsed.disallowRules.length > 0) {
+        const broadBlocks = robotsParsed.disallowRules.filter((r) => r === "/" || r === "/*" || r.startsWith("/?"));
+        if (broadBlocks.length > 0) {
+            crawlScore -= 20;
+            issues.push({
+                category: "Crawlability",
+                severity: "medium",
+                title: "Broad robots.txt disallow rules detected",
+                description: `User-agent: * has broad disallow rules: ${broadBlocks.join(", ")}.`,
+                recommendation: "Review robots.txt disallow rules — broad blocks may prevent legitimate crawling of important pages.",
+            });
+        }
+    }
     categoryScores["Crawlability"] = Math.max(0, crawlScore);
-    // --- Indexability ---
+    // ============================================================
+    // INDEXABILITY
+    // ============================================================
     let indexScore = 100;
+    // Meta robots noindex
     if (pageData.metaRobots?.toLowerCase().includes("noindex")) {
         indexScore -= 40;
         issues.push({
@@ -105,6 +131,32 @@ export async function auditTechnical(url, config, pageData, fetchResult) {
             recommendation: "Remove the noindex directive if this page should be indexed.",
         });
     }
+    // A. X-Robots-Tag header check
+    const xRobotsTag = fetchResult.headers["x-robots-tag"];
+    if (xRobotsTag) {
+        const xRobotsLower = xRobotsTag.toLowerCase();
+        if (xRobotsLower.includes("noindex")) {
+            indexScore -= 40;
+            issues.push({
+                category: "Indexability",
+                severity: "critical",
+                title: "Page blocked from indexing via X-Robots-Tag header",
+                description: `X-Robots-Tag header contains 'noindex': ${xRobotsTag}`,
+                recommendation: "Remove the noindex directive from the X-Robots-Tag header if this page should be indexed.",
+            });
+        }
+        if (xRobotsLower.includes("nofollow")) {
+            indexScore -= 10;
+            issues.push({
+                category: "Indexability",
+                severity: "medium",
+                title: "Links marked nofollow via X-Robots-Tag header",
+                description: `X-Robots-Tag header contains 'nofollow': ${xRobotsTag}`,
+                recommendation: "Review the nofollow directive in X-Robots-Tag — it prevents link equity flow from this page.",
+            });
+        }
+    }
+    // H1 checks (existing)
     if (pageData.h1Count === 0) {
         indexScore -= 15;
         issues.push({
@@ -119,26 +171,14 @@ export async function auditTechnical(url, config, pageData, fetchResult) {
         indexScore -= 10;
         issues.push({
             category: "Indexability",
-            severity: "low",
+            severity: "medium",
             title: "Multiple H1 headings",
-            description: `Found ${pageData.h1Count} H1 elements. Best practice is one H1 per page.`,
-            recommendation: "Use a single H1 per page; demote additional H1s to H2.",
+            description: `The page has ${pageData.h1Count} H1 elements.`,
+            recommendation: "Use a single H1 per page for clear content hierarchy.",
         });
     }
-    if (pageData.canonical) {
-        const canonicalUrl = new URL(pageData.canonical, fetchResult.finalUrl).href;
-        if (canonicalUrl !== fetchResult.finalUrl) {
-            indexScore -= 10;
-            issues.push({
-                category: "Indexability",
-                severity: "low",
-                title: "Canonical URL differs from page URL",
-                description: `canonical=${canonicalUrl}, url=${fetchResult.finalUrl}`,
-                recommendation: "Verify the canonical tag is correct — it may point to a different preferred URL intentionally.",
-            });
-        }
-    }
-    else {
+    // Canonical check (existing)
+    if (!pageData.canonical) {
         indexScore -= 10;
         issues.push({
             category: "Indexability",
@@ -148,8 +188,79 @@ export async function auditTechnical(url, config, pageData, fetchResult) {
             recommendation: "Add a self-referencing canonical tag to prevent duplicate content issues.",
         });
     }
+    // C. Cross-domain canonical check
+    if (pageData.canonical) {
+        try {
+            const canonicalHost = new URL(pageData.canonical).hostname;
+            const pageHost = new URL(pageData.url).hostname;
+            if (canonicalHost !== pageHost) {
+                indexScore -= 15;
+                issues.push({
+                    category: "Indexability",
+                    severity: "medium",
+                    title: "Cross-domain canonical URL",
+                    description: `Canonical points to ${canonicalHost} but page is on ${pageHost}.`,
+                    recommendation: "Ensure the cross-domain canonical is intentional (e.g., syndicated content). Otherwise, use a self-referencing canonical.",
+                });
+            }
+        }
+        catch {
+            // URL parsing failed — skip cross-domain check
+        }
+    }
+    // H. Soft 404 detection
+    if (fetchResult.statusCode === 200) {
+        if (pageData.wordCount < 50) {
+            indexScore -= 40;
+            issues.push({
+                category: "Indexability",
+                severity: "critical",
+                title: "Likely soft 404 — very thin content",
+                description: `Status 200 but only ${pageData.wordCount} words on page.`,
+                recommendation: "Add meaningful content to this page or return a proper 404/410 status for non-existent pages.",
+            });
+        }
+        else if (pageData.wordCount < 100 && pageData.h1Count === 0) {
+            indexScore -= 30;
+            issues.push({
+                category: "Indexability",
+                severity: "high",
+                title: "Possible soft 404 — thin content with no H1",
+                description: `Status 200 but only ${pageData.wordCount} words and no H1 heading.`,
+                recommendation: "Add a descriptive H1 and substantive content, or return a proper 404/410 status.",
+            });
+        }
+        if (fetchResult.contentLengthBytes < 1000) {
+            indexScore -= 20;
+            issues.push({
+                category: "Indexability",
+                severity: "medium",
+                title: "Very small response body — possible soft 404",
+                description: `Response body is only ${fetchResult.contentLengthBytes} bytes.`,
+                recommendation: "Ensure the page has meaningful content — very small responses may indicate empty or error pages.",
+            });
+        }
+    }
+    // I. Pagination detection
+    const hasNext = pageData.links.some((l) => l.rel.toLowerCase().includes("next"));
+    const hasPrev = pageData.links.some((l) => l.rel.toLowerCase().includes("prev"));
+    const paginationDetected = hasNext || hasPrev;
+    if (paginationDetected) {
+        if (!pageData.canonical) {
+            indexScore -= 10;
+            issues.push({
+                category: "Indexability",
+                severity: "low",
+                title: "Pagination detected but no canonical tag",
+                description: "Page has rel='next' or rel='prev' but no canonical URL.",
+                recommendation: "Add a self-referencing canonical tag to paginated pages to prevent indexing of parameterized variants.",
+            });
+        }
+    }
     categoryScores["Indexability"] = Math.max(0, indexScore);
-    // --- Security ---
+    // ============================================================
+    // SECURITY (existing)
+    // ============================================================
     let securityScore = 100;
     const isHttps = fetchResult.finalUrl.startsWith("https://");
     if (!isHttps) {
@@ -177,7 +288,9 @@ export async function auditTechnical(url, config, pageData, fetchResult) {
         }
     }
     categoryScores["Security"] = Math.max(0, securityScore);
-    // --- URL Structure ---
+    // ============================================================
+    // URL STRUCTURE (existing + G. redirect-chain quality)
+    // ============================================================
     let urlScore = 100;
     if (fetchResult.finalUrl.length > 100) {
         urlScore -= 10;
@@ -189,6 +302,7 @@ export async function auditTechnical(url, config, pageData, fetchResult) {
             recommendation: "Shorten the URL where possible for better readability and SEO.",
         });
     }
+    // Original redirect chain check (keep)
     if (fetchResult.redirectChain.length > 1) {
         urlScore -= 15;
         issues.push({
@@ -199,7 +313,50 @@ export async function auditTechnical(url, config, pageData, fetchResult) {
             recommendation: "Reduce redirect chains to a single hop (max 1 redirect).",
         });
     }
-    // Check for uppercase in path.
+    // G. Redirect-chain quality (extended)
+    const redirectChain = fetchResult.redirectChain;
+    const permanentStatuses = new Set([301, 308]);
+    const temporaryStatuses = new Set([302, 307]);
+    const permanentCount = redirectChain.filter((h) => permanentStatuses.has(h.status)).length;
+    const temporaryCount = redirectChain.filter((h) => temporaryStatuses.has(h.status)).length;
+    const redirectQualityIssues = [];
+    // Check final redirect uses temporary
+    if (redirectChain.length > 0) {
+        const lastHop = redirectChain[redirectChain.length - 1];
+        if (temporaryStatuses.has(lastHop.status)) {
+            redirectQualityIssues.push(`Final redirect hop uses status ${lastHop.status} (temporary) instead of 301 (permanent).`);
+            issues.push({
+                category: "URL Structure",
+                severity: "low",
+                title: "Temporary redirect used where permanent may be appropriate",
+                description: `Final redirect status is ${lastHop.status} (temporary).`,
+                recommendation: "Use 301 (permanent) redirects for permanently moved content to pass link equity.",
+            });
+        }
+    }
+    // Mixed permanent + temporary in chain
+    if (permanentCount > 0 && temporaryCount > 0) {
+        redirectQualityIssues.push(`Mixed redirect types: ${permanentCount} permanent + ${temporaryCount} temporary in chain.`);
+        issues.push({
+            category: "URL Structure",
+            severity: "low",
+            title: "Mixed permanent and temporary redirects in chain",
+            description: `Chain has ${permanentCount} permanent and ${temporaryCount} temporary redirects.`,
+            recommendation: "Use consistent redirect types — mixed chains can cause unpredictable caching and SEO behavior.",
+        });
+    }
+    // Chains longer than 3 hops
+    if (redirectChain.length > 3) {
+        urlScore -= 10;
+        issues.push({
+            category: "URL Structure",
+            severity: "medium",
+            title: "Long redirect chain (> 3 hops)",
+            description: `${redirectChain.length} redirect hops — each hop adds latency and dilutes link equity.`,
+            recommendation: "Reduce the redirect chain to at most 1–2 hops.",
+        });
+    }
+    // Uppercase URL path (existing)
     try {
         const path = new URL(fetchResult.finalUrl).pathname;
         if (path !== path.toLowerCase() && path.match(/[A-Z]/)) {
@@ -214,10 +371,12 @@ export async function auditTechnical(url, config, pageData, fetchResult) {
         }
     }
     catch {
-        // ignore
+        // URL parse failed — skip
     }
     categoryScores["URL Structure"] = Math.max(0, urlScore);
-    // --- Mobile Optimization ---
+    // ============================================================
+    // MOBILE (existing)
+    // ============================================================
     let mobileScore = 100;
     const mobileOptimized = !!pageData.viewport;
     if (!mobileOptimized) {
@@ -231,11 +390,12 @@ export async function auditTechnical(url, config, pageData, fetchResult) {
         });
     }
     categoryScores["Mobile"] = Math.max(0, mobileScore);
-    // --- AI Crawler Management ---
+    // ============================================================
+    // AI CRAWLERS (existing)
+    // ============================================================
     let aiScore = 100;
     if (robotsParsed.aiCrawlerRules.length === 0) {
-        // Not an error, but an opportunity.
-        aiScore -= 0;
+        aiScore -= 0; // informational only — no score penalty
         issues.push({
             category: "AI Crawlers",
             severity: "low",
@@ -245,11 +405,197 @@ export async function auditTechnical(url, config, pageData, fetchResult) {
         });
     }
     categoryScores["AI Crawlers"] = aiScore;
-    // --- Overall score ---
+    // ============================================================
+    // HREFLANG (new)
+    // ============================================================
+    let hreflangScore = 100;
+    const hreflangIssues = [];
+    const hreflangEntries = pageData.hreflang;
+    // B. Missing/empty href
+    for (const entry of hreflangEntries) {
+        if (!entry.href || entry.href.trim() === "") {
+            hreflangScore -= 15;
+            const msg = `Hreflang entry for lang "${entry.hreflang}" has missing or empty href.`;
+            hreflangIssues.push(msg);
+            issues.push({
+                category: "Hreflang",
+                severity: "medium",
+                title: "Hreflang entry with missing href",
+                description: msg,
+                recommendation: "Ensure every hreflang tag has a valid, absolute URL in its href attribute.",
+            });
+        }
+    }
+    // B. Self-referencing hreflang missing
+    if (hreflangEntries.length > 0) {
+        const pageUrl = fetchResult.finalUrl;
+        const hasSelfRef = hreflangEntries.some((e) => {
+            try {
+                return new URL(e.href).href === new URL(pageUrl).href;
+            }
+            catch {
+                return false;
+            }
+        });
+        if (!hasSelfRef) {
+            hreflangScore -= 10;
+            const msg = "No self-referencing hreflang tag found for the current page URL.";
+            hreflangIssues.push(msg);
+            issues.push({
+                category: "Hreflang",
+                severity: "low",
+                title: "Missing self-referencing hreflang",
+                description: msg,
+                recommendation: "Each page should include a self-referencing hreflang tag alongside alternate language tags.",
+            });
+        }
+    }
+    // B. Conflicting hreflang (same lang, different href)
+    const langMap = new Map();
+    for (const entry of hreflangEntries) {
+        if (!entry.hreflang || !entry.href)
+            continue;
+        const existing = langMap.get(entry.hreflang) ?? [];
+        existing.push(entry.href);
+        langMap.set(entry.hreflang, existing);
+    }
+    for (const [lang, hrefs] of langMap) {
+        const uniqueHrefs = [...new Set(hrefs)];
+        if (uniqueHrefs.length > 1) {
+            hreflangScore -= 15;
+            const msg = `Conflicting hreflang entries for lang "${lang}": ${uniqueHrefs.join(", ")}.`;
+            hreflangIssues.push(msg);
+            issues.push({
+                category: "Hreflang",
+                severity: "medium",
+                title: "Conflicting hreflang entries",
+                description: msg,
+                recommendation: `Fix duplicate or conflicting hreflang tags for "${lang}" — each language should have exactly one URL.`,
+            });
+        }
+    }
+    categoryScores["Hreflang"] = Math.max(0, hreflangScore);
+    // ============================================================
+    // CONTENT TYPE (new)
+    // ============================================================
+    let contentTypeScore = 100;
+    const contentTypeHeader = fetchResult.headers["content-type"] ?? null;
+    if (!contentTypeHeader) {
+        contentTypeScore -= 20;
+        issues.push({
+            category: "Content Type",
+            severity: "high",
+            title: "Missing Content-Type header",
+            description: "The response does not include a Content-Type header.",
+            recommendation: "Configure the server to always send a Content-Type header (e.g., text/html; charset=utf-8).",
+        });
+    }
+    else if (!contentTypeHeader.toLowerCase().includes("text/html")) {
+        contentTypeScore -= 20;
+        issues.push({
+            category: "Content Type",
+            severity: "high",
+            title: "Non-HTML Content-Type header",
+            description: `Content-Type is "${contentTypeHeader}" — expected "text/html".`,
+            recommendation: "Ensure HTML pages are served with Content-Type: text/html for proper rendering and indexing.",
+        });
+    }
+    else {
+        // Has text/html — check for charset
+        if (!/charset=/i.test(contentTypeHeader)) {
+            contentTypeScore -= 5;
+            issues.push({
+                category: "Content Type",
+                severity: "low",
+                title: "Content-Type missing charset parameter",
+                description: `Content-Type is "${contentTypeHeader}" but no charset parameter found.`,
+                recommendation: "Add charset=utf-8 to the Content-Type header to ensure correct character decoding.",
+            });
+        }
+    }
+    categoryScores["Content Type"] = Math.max(0, contentTypeScore);
+    // ============================================================
+    // COMPRESSION & CACHING (new)
+    // ============================================================
+    let compressionCacheScore = 100;
+    const contentEncoding = fetchResult.headers["content-encoding"] ?? null;
+    const cacheControl = fetchResult.headers["cache-control"];
+    const etag = fetchResult.headers["etag"];
+    const lastModified = fetchResult.headers["last-modified"];
+    // E. Compression check
+    if (!contentEncoding) {
+        compressionCacheScore -= 5;
+        issues.push({
+            category: "Compression & Caching",
+            severity: "low",
+            title: "No content compression",
+            description: "Content-Encoding header is missing — response is sent uncompressed.",
+            recommendation: "Enable gzip or brotli compression on the server to reduce transfer size.",
+        });
+    }
+    else {
+        const validEncodings = ["gzip", "br", "deflate"];
+        if (!validEncodings.includes(contentEncoding.toLowerCase())) {
+            issues.push({
+                category: "Compression & Caching",
+                severity: "low",
+                title: "Uncommon content encoding",
+                description: `Content-Encoding is "${contentEncoding}" — not one of gzip, br, deflate.`,
+                recommendation: "Use gzip or brotli for broad browser compatibility and efficiency.",
+            });
+        }
+    }
+    // F. Cache headers
+    if (!cacheControl) {
+        compressionCacheScore -= 5;
+        issues.push({
+            category: "Compression & Caching",
+            severity: "low",
+            title: "Missing Cache-Control header",
+            description: "No Cache-Control header found — browsers may use heuristic caching.",
+            recommendation: "Set an explicit Cache-Control header to define caching behavior.",
+        });
+    }
+    if (!etag && !lastModified) {
+        compressionCacheScore -= 5;
+        issues.push({
+            category: "Compression & Caching",
+            severity: "low",
+            title: "Missing cache validation headers",
+            description: "Neither ETag nor Last-Modified header is present.",
+            recommendation: "Add ETag or Last-Modified headers to enable conditional requests and efficient revalidation.",
+        });
+    }
+    if (cacheControl && cacheControl.toLowerCase().includes("no-store")) {
+        issues.push({
+            category: "Compression & Caching",
+            severity: "low",
+            title: "Cache-Control: no-store may impact bfcache",
+            description: "Cache-Control header contains 'no-store', which prevents back/forward cache usage.",
+            recommendation: "Avoid 'no-store' unless absolutely necessary — it degrades navigation performance for returning visitors.",
+        });
+    }
+    categoryScores["Compression & Caching"] = Math.max(0, compressionCacheScore);
+    // ============================================================
+    // COMPUTE OVERALL SCORE
+    // ============================================================
     const scores = Object.values(categoryScores);
-    const overallScore = scores.length > 0
-        ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length)
-        : 0;
+    const overallScore = scores.length > 0 ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length) : 0;
+    // ============================================================
+    // SOFT 404 RISK (derived from checks above)
+    // ============================================================
+    let soft404Risk = "none";
+    if (fetchResult.statusCode === 200) {
+        if (pageData.wordCount < 50) {
+            soft404Risk = "high";
+        }
+        else if (pageData.wordCount < 100 && pageData.h1Count === 0) {
+            soft404Risk = "high";
+        }
+        else if (fetchResult.contentLengthBytes < 1000) {
+            soft404Risk = "low";
+        }
+    }
     return {
         url: fetchResult.finalUrl,
         score: overallScore,
@@ -260,9 +606,34 @@ export async function auditTechnical(url, config, pageData, fetchResult) {
             sitemapDeclared: robotsParsed.sitemapDeclared,
             aiCrawlerRules: robotsParsed.aiCrawlerRules,
             content: robotsContent || undefined,
+            disallowRules: robotsParsed.disallowRules,
+            sitemapUrls: robotsParsed.sitemapUrls,
         },
         securityHeaders,
         isHttps,
         mobileOptimized,
+        hreflang: {
+            entries: pageData.hreflang.length,
+            issues: hreflangIssues,
+        },
+        contentType: contentTypeHeader,
+        compression: contentEncoding,
+        cacheHeaders: {
+            cacheControl,
+            etag,
+            lastModified,
+        },
+        redirectChainQuality: {
+            hops: redirectChain.length,
+            permanentRedirects: permanentCount,
+            temporaryRedirects: temporaryCount,
+            issues: redirectQualityIssues,
+        },
+        soft404Risk,
+        pagination: {
+            detected: paginationDetected,
+            hasNext,
+            hasPrev,
+        },
     };
 }

package/dist/extensions/seo/config.d.ts

@@ -19,6 +19,8 @@ export interface SeoConfig {
     blockRenderResources: string[];
     /** Whether SSRF protection is enabled (blocks private/internal IPs). */
     ssrfProtection: boolean;
+    maxResponseBytes: number;
+    stopWords: string[];
 }
 export declare function loadSeoConfig(): SeoConfig;
 //# sourceMappingURL=config.d.ts.map

package/dist/extensions/seo/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/extensions/seo/config.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,SAAS;IACxB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,mDAAmD;IACnD,eAAe,EAAE,OAAO,CAAC;IACzB,6CAA6C;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,eAAe,EAAE,SAAS,GAAG,QAAQ,CAAC;IACtC,iEAAiE;IACjE,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,wEAAwE;IACxE,cAAc,EAAE,OAAO,CAAC;CACzB;AA8BD,wBAAgB,aAAa,IAAI,SAAS,CAezC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/extensions/seo/config.ts"],"names":[],"mappings":"AASA,MAAM,WAAW,SAAS;IACxB,+CAA+C;IAC/C,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,SAAS,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,kBAAkB,EAAE,MAAM,CAAC;IAC3B,mDAAmD;IACnD,eAAe,EAAE,OAAO,CAAC;IACzB,6CAA6C;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB,oDAAoD;IACpD,MAAM,EAAE,MAAM,CAAC;IACf,sCAAsC;IACtC,eAAe,EAAE,SAAS,GAAG,QAAQ,CAAC;IACtC,iEAAiE;IACjE,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAC/B,wEAAwE;IACxE,cAAc,EAAE,OAAO,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AA8BD,wBAAgB,aAAa,IAAI,SAAS,CAiBzC"}

package/dist/extensions/seo/config.js

@@ -44,5 +44,7 @@ export function loadSeoConfig() {
         defaultViewport: process.env.SEO_VIEWPORT ?? "desktop",
         blockRenderResources: envList("SEO_BLOCK_RESOURCES", ["image", "font", "stylesheet"]),
         ssrfProtection: envBool("SEO_SSRF_PROTECTION", true),
+        maxResponseBytes: envInt("SEO_MAX_RESPONSE_BYTES", 10 * 1024 * 1024),
+        stopWords: envList("SEO_STOP_WORDS", []),
     };
 }

package/dist/extensions/seo/tools/batch.js

@@ -41,7 +41,7 @@ export function registerBatchTools(ext, config) {
                         const pageData = parsePage(fetchResult.content, fetchResult.finalUrl);
                         const technical = await auditTechnical(url, config, pageData, fetchResult);
                         const text = extractText(fetchResult.content);
-                        const content = analyzeContentQuality(text, fetchResult.finalUrl);
+                        const content = analyzeContentQuality(text, fetchResult.finalUrl, pageData);
                         results.push({
                             url: fetchResult.finalUrl,
                             status: fetchResult.statusCode,

package/dist/extensions/seo/tools/content.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/tools/content.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,oCAAoC,CAAC;AACvF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAM9C,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAyD/E"}
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/tools/content.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,oCAAoC,CAAC;AACvF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAM9C,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CA2D/E"}

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

@@ -1,6 +1,6 @@
 import { analyzeContentQuality } from "../analyzers/content.js";
 import { fetchPage } from "../utils/fetcher.js";
-import { extractText } from "../utils/parser.js";
+import { extractContentText, parsePage } from "../utils/parser.js";
 import { errorResult, textResult } from "./helpers.js";
 export function registerContentTools(ext, config) {
     const contentTool = {
@@ -22,18 +22,20 @@ export function registerContentTools(ext, config) {
             try {
                 let content = text ?? "";
                 let effectiveUrl;
+                let pageData = undefined;
                 if (url && !text) {
                     const result = await fetchPage(url, config);
                     if (result.error) {
                         return errorResult(`Fetch failed: ${result.error}`);
                     }
-                    content = extractText(result.content);
+                    content = extractContentText(result.content);
                     effectiveUrl = result.finalUrl;
+                    pageData = parsePage(result.content, result.finalUrl);
                 }
                 if (!content) {
                     return errorResult("Either 'url' or 'text' must be provided.");
                 }
-                const result = analyzeContentQuality(content, effectiveUrl);
+                const result = analyzeContentQuality(content, effectiveUrl, pageData, config.stopWords);
                 const summary = `✓ Content Quality Analysis${effectiveUrl ? `: ${effectiveUrl}` : ""}\n` +
                     `Word Count: ${result.wordCount}\n` +
                     `Overall Quality: ${result.overallQuality}/100\n\n` +

package/dist/extensions/seo/tools/full-audit.d.ts

@@ -6,6 +6,6 @@
  */
 import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
 import type { SeoConfig } from "../config.js";
-export type AuditCategory = "technical" | "content" | "schema" | "images" | "preload" | "agentUx";
+export type AuditCategory = "technical" | "content" | "schema" | "images" | "preload" | "agentUx" | "performance";
 export declare function registerFullAuditTools(ext: ExtensionAPI, config: SeoConfig): void;
 //# sourceMappingURL=full-audit.d.ts.map

package/dist/extensions/seo/tools/full-audit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"full-audit.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/tools/full-audit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,oCAAoC,CAAC;AACvF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAa9C,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,CAAC;AAIlG,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CA+DjF"}
+{"version":3,"file":"full-audit.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/tools/full-audit.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,oCAAoC,CAAC;AACvF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAe9C,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,CAAC;AAIlH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CAqEjF"}