@aexol/spectral 0.9.42 → 0.9.43

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

@@ -0,0 +1,108 @@
+const SPECULATION_BLOCK_RE = /<script\b[^>]*\btype\s*=\s*["']speculationrules["'][^>]*>([\s\S]*?)<\/script>/gi;
+const PRELOAD_LINK_RE = /<link\b[^>]*\brel\s*=\s*["']preload["'][^>]*>/gi;
+const PRERENDER_LINK_RE = /<link\b[^>]*\brel\s*=\s*["']prerender["'][^>]*>/gi;
+const FETCHPRIORITY_HIGH_RE = /\bfetchpriority\s*=\s*["']high["']/gi;
+const LCP_IMG_HINT_RE = /<(?:img|video|source)\b[^>]*\bfetchpriority\s*=\s*["']high["']/gi;
+const UNLOAD_LISTENER_RE = /(?:addEventListener\s*\(\s*["']?unload["']?|\.onunload\s*=|on\s*\(\s*["']?unload["'])/i;
+const BEFOREUNLOAD_LISTENER_RE = /(?:addEventListener\s*\(\s*["']?beforeunload["']?|\.onbeforeunload\s*=|on\s*\(\s*["']?beforeunload["'])/i;
+function extractSpeculationActions(body) {
+    const actions = new Set();
+    try {
+        const payload = JSON.parse(body.trim());
+        if (Array.isArray(payload.prefetch))
+            actions.add("prefetch");
+        if (Array.isArray(payload.prerender))
+            actions.add("prerender");
+    }
+    catch {
+        // invalid JSON
+    }
+    return [...actions].sort();
+}
+export function auditPreload(fetchResult) {
+    const html = fetchResult.content;
+    const headers = fetchResult.headers;
+    // Speculation rules.
+    const speculationBlocks = [];
+    let match;
+    while ((match = SPECULATION_BLOCK_RE.exec(html)) !== null) {
+        speculationBlocks.push(match[1]);
+    }
+    const actions = new Set();
+    for (const block of speculationBlocks) {
+        for (const a of extractSpeculationActions(block)) {
+            actions.add(a);
+        }
+    }
+    const speculationHeader = Object.keys(headers).some((k) => k.toLowerCase() === "speculation-rules");
+    // Preload hints.
+    const preloadMatches = html.match(PRELOAD_LINK_RE) ?? [];
+    const preloadHints = preloadMatches.length;
+    // Deprecated prerender links.
+    const prerenderMatches = html.match(PRERENDER_LINK_RE) ?? [];
+    const prerenderLinks = prerenderMatches.length;
+    // bfcache signals.
+    const ccValue = Object.entries(headers).find(([k]) => k.toLowerCase() === "cache-control")?.[1] ?? "";
+    const cacheControlNoStore = ccValue.toLowerCase().includes("no-store");
+    const hasUnload = UNLOAD_LISTENER_RE.test(html);
+    const hasBeforeunload = BEFOREUNLOAD_LISTENER_RE.test(html);
+    // LCP resource hints.
+    const fetchpriorityMatches = html.match(FETCHPRIORITY_HIGH_RE) ?? [];
+    const lcpImgHint = LCP_IMG_HINT_RE.test(html);
+    // Score.
+    let score = 0;
+    const recommendations = [];
+    if (speculationBlocks.length > 0 || speculationHeader) {
+        score += 25;
+    }
+    else {
+        recommendations.push('Add <script type="speculationrules"> for prefetch+prerender on top user-paths. Saves entire next-navigation paint cost.');
+    }
+    if (lcpImgHint) {
+        score += 25;
+    }
+    else {
+        recommendations.push('Mark the LCP hero image with fetchpriority="high" so the browser preloads it ahead of other resources.');
+    }
+    if (!cacheControlNoStore && !hasUnload) {
+        score += 25;
+    }
+    else {
+        if (cacheControlNoStore) {
+            recommendations.push('Remove "Cache-Control: no-store" to enable bfcache restoration on back/forward navigation.');
+        }
+        if (hasUnload) {
+            recommendations.push('Remove "unload" event listeners (use "pagehide" instead) — they block bfcache.');
+        }
+    }
+    if (preloadHints > 0) {
+        score += 25;
+    }
+    else {
+        recommendations.push('Add <link rel="preload"> for critical resources (fonts, CSS, hero image) to speed up LCP.');
+    }
+    if (prerenderLinks > 0) {
+        recommendations.push('Replace deprecated <link rel="prerender"> with Speculation Rules API for modern prerendering.');
+    }
+    return {
+        url: fetchResult.finalUrl,
+        speculationRules: {
+            inlineBlocks: speculationBlocks.length,
+            headerPresent: speculationHeader,
+            actions: [...actions],
+        },
+        preloadHints,
+        prerenderLinks,
+        bfcacheSignals: {
+            cacheControlNoStore,
+            unloadListener: hasUnload,
+            beforeunloadListener: hasBeforeunload,
+        },
+        lcpResourceHints: {
+            preloadLcpCandidate: lcpImgHint,
+            fetchpriorityHigh: fetchpriorityMatches.length,
+        },
+        score,
+        recommendations,
+    };
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Schema.org analyzer — detection, validation, and generation.
+ *
+ * Ported from the Python `schema_generate.py` and `seo-schema/SKILL.md` in
+ * claude-seo. Generates JSON-LD for high-leverage types and validates existing
+ * markup against Google's rich result requirements.
+ */
+import type { SchemaAuditResult } from "../types.js";
+/** Audit schema markup on a page. */
+export declare function auditSchema(html: string, url?: string): SchemaAuditResult;
+export interface SchemaGenerateParams {
+    type: "Organization" | "LocalBusiness" | "Article" | "BlogPosting" | "Product" | "BreadcrumbList" | "WebSite" | "Person" | "ProfilePage" | "DiscussionForumPosting" | "OrderAction" | "Reservation";
+    [key: string]: unknown;
+}
+/** Generate JSON-LD for the specified schema type. */
+export declare function generateSchema(params: SchemaGenerateParams): {
+    jsonLd: unknown;
+    type: string;
+    required: string[];
+};
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,iBAAiB,EAAe,MAAM,aAAa,CAAC;AA2FlE,qCAAqC;AACrC,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,iBAAiB,CA2DzE;AAID,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,cAAc,GAAG,eAAe,GAAG,SAAS,GAAG,aAAa,GAAG,SAAS,GAC5E,gBAAgB,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,GAAG,wBAAwB,GAClF,aAAa,GAAG,aAAa,CAAC;IAChC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,sDAAsD;AACtD,wBAAgB,cAAc,CAAC,MAAM,EAAE,oBAAoB,GAAG;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,CAsMlH"}

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

@@ -0,0 +1,324 @@
+import { extractJsonLd, parsePage } from "../utils/parser.js";
+/** Schema types deprecated by Google (no rich results as of 2026). */
+const DEPRECATED_TYPES = new Set([
+    "HowTo",
+    "SpecialAnnouncement",
+    "CourseInfo",
+    "EstimatedSalary",
+    "LearningVideo",
+    "ClaimReview",
+    "VehicleListing",
+    "PracticeProblem",
+    "Dataset",
+    "FAQPage",
+]);
+/** Active schema types that Google supports for rich results. */
+const ACTIVE_TYPES = new Set([
+    "Organization", "LocalBusiness", "SoftwareApplication", "WebApplication",
+    "Product", "ProductGroup", "Offer", "Service", "Article", "BlogPosting",
+    "NewsArticle", "Review", "AggregateRating", "BreadcrumbList", "WebSite",
+    "WebPage", "Person", "ProfilePage", "ContactPage", "VideoObject",
+    "ImageObject", "Event", "JobPosting", "Course", "DiscussionForumPosting",
+    "Reservation", "OrderAction",
+]);
+/** Required properties per schema type (subset of Google's requirements). */
+const REQUIRED_PROPERTIES = {
+    Article: ["headline", "author", "datePublished", "image", "publisher"],
+    BlogPosting: ["headline", "author", "datePublished", "image"],
+    NewsArticle: ["headline", "datePublished", "author", "image", "publisher"],
+    Product: ["name", "offers"],
+    Organization: ["name", "url"],
+    LocalBusiness: ["name", "address"],
+    Event: ["name", "startDate", "location"],
+    Review: ["itemReviewed", "author", "reviewRating"],
+    BreadcrumbList: ["itemListElement"],
+    VideoObject: ["name", "uploadDate"],
+    JobPosting: ["title", "description", "hiringOrganization"],
+    Course: ["name", "provider"],
+};
+/** Validate a parsed JSON-LD object and return issues. */
+function validateSchemaItem(item) {
+    if (!item || typeof item !== "object") {
+        return { type: "Unknown", issues: ["Invalid schema object"] };
+    }
+    const obj = item;
+    const rawType = obj["@type"];
+    // Handle @type arrays (e.g. ["Article", "NewsArticle"]) and full URLs.
+    const type = typeof rawType === "string"
+        ? rawType.replace("https://schema.org/", "")
+        : Array.isArray(rawType) && rawType.length > 0
+            ? rawType[0].replace("https://schema.org/", "")
+            : "Unknown";
+    const issues = [];
+    if (!obj["@context"]) {
+        issues.push("Missing @context");
+    }
+    // Check required properties.
+    const required = REQUIRED_PROPERTIES[type];
+    if (required) {
+        for (const prop of required) {
+            if (!(prop in obj)) {
+                issues.push(`Missing required property: ${prop}`);
+            }
+        }
+    }
+    // Check for relative URLs.
+    const jsonStr = JSON.stringify(obj);
+    if (jsonStr.includes('"url":"/') || jsonStr.includes('"url": "/')) {
+        issues.push("Contains relative URL — should be absolute");
+    }
+    // Check date formats.
+    for (const dateField of ["datePublished", "dateModified", "startDate", "endDate", "uploadDate"]) {
+        const val = obj[dateField];
+        if (typeof val === "string" && val.length > 0) {
+            if (isNaN(Date.parse(val))) {
+                issues.push(`Invalid date format for ${dateField}: ${val}`);
+            }
+        }
+    }
+    return { type, issues };
+}
+/** Audit schema markup on a page. */
+export function auditSchema(html, url) {
+    const pageData = parsePage(html, url);
+    const detectedSchemas = pageData.schemaBlocks;
+    const deprecatedTypes = [];
+    const relativeUrls = [];
+    const invalidDates = [];
+    let missingContext = false;
+    // Re-validate with deeper checks using parsed JSON-LD.
+    const jsonLdItems = extractJsonLd(html);
+    for (const item of jsonLdItems) {
+        const { type, issues } = validateSchemaItem(item);
+        if (DEPRECATED_TYPES.has(type)) {
+            deprecatedTypes.push(type);
+        }
+        for (const issue of issues) {
+            if (issue.includes("relative URL"))
+                relativeUrls.push(type);
+            if (issue.includes("Invalid date"))
+                invalidDates.push(type);
+            if (issue.includes("Missing @context"))
+                missingContext = true;
+        }
+    }
+    const recommendations = [];
+    if (deprecatedTypes.length > 0) {
+        recommendations.push(`Deprecated schema types detected: ${deprecatedTypes.join(", ")}. These no longer produce rich results.`);
+    }
+    if (missingContext) {
+        recommendations.push('Add "@context": "https://schema.org" to all JSON-LD blocks.');
+    }
+    if (relativeUrls.length > 0) {
+        recommendations.push("Use absolute URLs in all schema properties.");
+    }
+    if (detectedSchemas.length === 0) {
+        recommendations.push("No structured data found. Add JSON-LD markup for rich result eligibility.");
+    }
+    // Recommend types based on page content.
+    const hasArticle = pageData.wordCount > 300 && (pageData.title ?? "").length > 0;
+    if (hasArticle && !detectedSchemas.some((s) => ["Article", "BlogPosting", "NewsArticle"].includes(s.type))) {
+        recommendations.push("Consider adding Article or BlogPosting schema for content pages.");
+    }
+    if (detectedSchemas.length > 0 && !detectedSchemas.some((s) => s.type === "BreadcrumbList")) {
+        recommendations.push("Add BreadcrumbList schema to improve navigation rich results.");
+    }
+    return {
+        url,
+        detectedSchemas,
+        deprecatedTypes,
+        missingContext,
+        relativeUrls,
+        invalidDates,
+        recommendations,
+    };
+}
+/** Generate JSON-LD for the specified schema type. */
+export function generateSchema(params) {
+    const { type, ...rest } = params;
+    const context = "https://schema.org";
+    switch (type) {
+        case "Organization":
+            return {
+                jsonLd: {
+                    "@context": context,
+                    "@type": "Organization",
+                    name: rest.name ?? "[Company Name]",
+                    url: rest.url ?? "[Website URL]",
+                    logo: rest.logo ?? "[Logo URL]",
+                    sameAs: rest.sameAs ?? [],
+                    ...(rest.contactPoint ? { contactPoint: rest.contactPoint } : {}),
+                },
+                type: "Organization",
+                required: ["name", "url"],
+            };
+        case "LocalBusiness":
+            return {
+                jsonLd: {
+                    "@context": context,
+                    "@type": "LocalBusiness",
+                    name: rest.name ?? "[Business Name]",
+                    address: rest.address ?? {
+                        "@type": "PostalAddress",
+                        streetAddress: "[Street]",
+                        addressLocality: "[City]",
+                        addressRegion: "[State]",
+                        postalCode: "[ZIP]",
+                        addressCountry: "[Country]",
+                    },
+                    telephone: rest.telephone ?? "[Phone]",
+                    openingHours: rest.openingHours ?? "Mo-Fr 09:00-17:00",
+                    ...(rest.geo ? { geo: rest.geo } : {}),
+                },
+                type: "LocalBusiness",
+                required: ["name", "address"],
+            };
+        case "Article":
+        case "BlogPosting":
+            return {
+                jsonLd: {
+                    "@context": context,
+                    "@type": type,
+                    headline: rest.headline ?? "[Title]",
+                    author: { "@type": "Person", name: rest.author ?? "[Author Name]" },
+                    datePublished: rest.datePublished ?? "[YYYY-MM-DD]",
+                    dateModified: rest.dateModified ?? rest.datePublished ?? "[YYYY-MM-DD]",
+                    image: rest.image ?? "[Image URL]",
+                    publisher: {
+                        "@type": "Organization",
+                        name: rest.publisher ?? "[Publisher]",
+                        logo: { "@type": "ImageObject", url: rest.publisherLogo ?? "[Logo URL]" },
+                    },
+                    ...(rest.url ? { mainEntityOfPage: { "@type": "WebPage", "@id": rest.url } } : {}),
+                },
+                type,
+                required: ["headline", "author", "datePublished", "image", "publisher"],
+            };
+        case "Product":
+            return {
+                jsonLd: {
+                    "@context": context,
+                    "@type": "Product",
+                    name: rest.name ?? "[Product Name]",
+                    image: rest.image ?? "[Image URL]",
+                    description: rest.description ?? "[Description]",
+                    offers: rest.offers ?? {
+                        "@type": "Offer",
+                        price: rest.price ?? "0",
+                        priceCurrency: rest.priceCurrency ?? "USD",
+                        availability: `https://schema.org/${rest.availability ?? "InStock"}`,
+                    },
+                    ...(rest.brand ? { brand: { "@type": "Brand", name: rest.brand } } : {}),
+                    ...(rest.aggregateRating ? { aggregateRating: rest.aggregateRating } : {}),
+                },
+                type: "Product",
+                required: ["name", "offers"],
+            };
+        case "BreadcrumbList":
+            return {
+                jsonLd: {
+                    "@context": context,
+                    "@type": "BreadcrumbList",
+                    itemListElement: (rest.items ?? []).map((item, i) => ({
+                        "@type": "ListItem",
+                        position: i + 1,
+                        name: item.name,
+                        item: item.url,
+                    })),
+                },
+                type: "BreadcrumbList",
+                required: ["itemListElement"],
+            };
+        case "WebSite":
+            return {
+                jsonLd: {
+                    "@context": context,
+                    "@type": "WebSite",
+                    name: rest.name ?? "[Site Name]",
+                    url: rest.url ?? "[Site URL]",
+                    ...(rest.potentialAction ? { potentialAction: rest.potentialAction } : {}),
+                },
+                type: "WebSite",
+                required: ["name", "url"],
+            };
+        case "Person":
+        case "ProfilePage":
+            return {
+                jsonLd: {
+                    "@context": context,
+                    "@type": type,
+                    name: rest.name ?? "[Name]",
+                    url: rest.url ?? "[Profile URL]",
+                    ...(rest.sameAs ? { sameAs: rest.sameAs } : {}),
+                    ...(rest.knowsAbout ? { knowsAbout: rest.knowsAbout } : {}),
+                    ...(rest.jobTitle ? { jobTitle: rest.jobTitle } : {}),
+                    ...(rest.worksFor ? { worksFor: { "@type": "Organization", name: rest.worksFor } } : {}),
+                    ...(rest.image ? { image: rest.image } : {}),
+                },
+                type,
+                required: ["name", "url"],
+            };
+        case "DiscussionForumPosting":
+            return {
+                jsonLd: {
+                    "@context": context,
+                    "@type": "DiscussionForumPosting",
+                    headline: rest.headline ?? "[Headline]",
+                    author: { "@type": "Person", name: rest.author ?? "[Author]" },
+                    datePublished: rest.datePublished ?? "[YYYY-MM-DD]",
+                    url: rest.url ?? "[URL]",
+                    mainEntityOfPage: { "@type": "WebPage", "@id": rest.url ?? "[URL]" },
+                    ...(rest.text ? { text: rest.text } : {}),
+                    ...(rest.dateModified ? { dateModified: rest.dateModified } : {}),
+                    ...(rest.commentCount !== undefined ? { commentCount: rest.commentCount } : {}),
+                },
+                type: "DiscussionForumPosting",
+                required: ["headline", "author", "datePublished", "url"],
+            };
+        case "OrderAction":
+            return {
+                jsonLd: {
+                    "@context": context,
+                    "@type": "OrderAction",
+                    name: rest.name ?? "Order online",
+                    target: {
+                        "@type": "EntryPoint",
+                        urlTemplate: rest.orderUrl ?? "[Order URL]",
+                        inLanguage: "en-US",
+                        actionPlatform: [
+                            "https://schema.org/DesktopWebPlatform",
+                            "https://schema.org/MobileWebPlatform",
+                        ],
+                    },
+                    deliveryMethod: rest.deliveryMethod ?? [
+                        "https://schema.org/OnSitePickup",
+                        "https://schema.org/ParcelService",
+                    ],
+                    merchant: { "@type": "Organization", name: rest.merchant ?? "[Merchant]" },
+                },
+                type: "OrderAction",
+                required: ["orderUrl", "merchant"],
+            };
+        case "Reservation":
+            return {
+                jsonLd: {
+                    "@context": context,
+                    "@type": rest.kind ?? "FoodEstablishmentReservation",
+                    reservationStatus: "https://schema.org/ReservationConfirmed",
+                    provider: { "@type": "Organization", name: rest.provider ?? "[Provider]" },
+                    reservationFor: {
+                        "@type": rest.kind === "FoodEstablishmentReservation" ? "FoodEstablishment" : "Place",
+                        name: rest.reservationForName ?? rest.provider ?? "[Name]",
+                    },
+                    startTime: rest.start ?? "[Start Time]",
+                    ...(rest.end ? { endTime: rest.end } : {}),
+                    ...(rest.partySize !== undefined ? { partySize: rest.partySize } : {}),
+                    ...(rest.reservationId ? { reservationId: rest.reservationId } : {}),
+                },
+                type: "Reservation",
+                required: ["provider", "start"],
+            };
+        default:
+            return { jsonLd: { "@context": context, "@type": "Thing" }, type: "Unknown", required: [] };
+    }
+}

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

@@ -0,0 +1,20 @@
+/**
+ * XML sitemap analyzer and generator.
+ *
+ * Ported from the Python `seo-sitemap/SKILL.md` directives in claude-seo.
+ * Parses sitemap XML (including sitemap index files) and generates valid
+ * XML sitemaps from URL lists.
+ */
+import type { SitemapAnalysisResult } from "../types.js";
+import type { SeoConfig } from "../config.js";
+/** Analyze a sitemap at a given URL. */
+export declare function analyzeSitemap(sitemapUrl: string, config: SeoConfig): Promise<SitemapAnalysisResult>;
+export interface SitemapGenerateEntry {
+    loc: string;
+    lastmod?: string;
+    changefreq?: string;
+    priority?: number;
+}
+/** Generate an XML sitemap from a list of URLs. */
+export declare function generateSitemap(entries: SitemapGenerateEntry[]): string;
+//# sourceMappingURL=sitemap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sitemap.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/sitemap.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AA8C9C,wCAAwC;AACxC,wBAAsB,cAAc,CAClC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,SAAS,GAChB,OAAO,CAAC,qBAAqB,CAAC,CA4DhC;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,mDAAmD;AACnD,wBAAgB,eAAe,CAAC,OAAO,EAAE,oBAAoB,EAAE,GAAG,MAAM,CAuBvE"}

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

@@ -0,0 +1,121 @@
+import { fetchPage } from "../utils/fetcher.js";
+/** Parse a sitemap XML string into URLs. */
+function parseSitemapXml(xml) {
+    const urls = [];
+    const childSitemaps = [];
+    const isIndex = /<sitemapindex/i.test(xml);
+    if (isIndex) {
+        const sitemapRegex = /<sitemap>([\s\S]*?)<\/sitemap>/gi;
+        let match;
+        while ((match = sitemapRegex.exec(xml)) !== null) {
+            const locMatch = /<loc>(.*?)<\/loc>/i.exec(match[1]);
+            if (locMatch) {
+                childSitemaps.push(locMatch[1].trim());
+            }
+        }
+        return { urls, isIndex: true, childSitemaps };
+    }
+    const urlRegex = /<url>([\s\S]*?)<\/url>/gi;
+    let match;
+    while ((match = urlRegex.exec(xml)) !== null) {
+        const block = match[1];
+        const loc = /<loc>(.*?)<\/loc>/i.exec(block)?.[1]?.trim();
+        if (loc) {
+            urls.push({
+                loc,
+                lastmod: /<lastmod>(.*?)<\/lastmod>/i.exec(block)?.[1]?.trim(),
+                changefreq: /<changefreq>(.*?)<\/changefreq>/i.exec(block)?.[1]?.trim(),
+                priority: /<priority>(.*?)<\/priority>/i.exec(block)?.[1]?.trim(),
+            });
+        }
+    }
+    return { urls, isIndex: false, childSitemaps };
+}
+/** Analyze a sitemap at a given URL. */
+export async function analyzeSitemap(sitemapUrl, config) {
+    const result = await fetchPage(sitemapUrl, config);
+    const warnings = [];
+    if (result.statusCode !== 200) {
+        return {
+            url: sitemapUrl,
+            urlCount: 0,
+            urls: [],
+            lastmodCoverage: 0,
+            invalidEntries: 0,
+            sizeBytes: result.contentLengthBytes,
+            isSitemapIndex: false,
+            childSitemaps: [],
+            warnings: [`Sitemap returned status ${result.statusCode}`],
+        };
+    }
+    const parsed = parseSitemapXml(result.content);
+    // Validate URLs.
+    let invalidEntries = 0;
+    const validUrls = [];
+    for (const u of parsed.urls) {
+        try {
+            new URL(u.loc);
+            validUrls.push(u.loc);
+        }
+        catch {
+            invalidEntries++;
+        }
+    }
+    // Calculate lastmod coverage.
+    const withLastmod = parsed.urls.filter((u) => u.lastmod).length;
+    const lastmodCoverage = parsed.urls.length > 0
+        ? Math.round((withLastmod / parsed.urls.length) * 100)
+        : 0;
+    // Size warnings.
+    if (result.contentLengthBytes > 50_000_000) {
+        warnings.push("Sitemap exceeds 50MB uncompressed limit. Split into multiple sitemaps.");
+    }
+    if (parsed.urls.length > 50_000) {
+        warnings.push("Sitemap contains more than 50,000 URLs. Split into multiple sitemaps.");
+    }
+    if (lastmodCoverage < 50 && parsed.urls.length > 0) {
+        warnings.push(`Only ${lastmodCoverage}% of URLs have lastmod dates. Adding lastmod improves crawl efficiency.`);
+    }
+    return {
+        url: result.finalUrl,
+        urlCount: parsed.urls.length,
+        urls: validUrls,
+        lastmodCoverage,
+        invalidEntries,
+        sizeBytes: result.contentLengthBytes,
+        isSitemapIndex: parsed.isIndex,
+        childSitemaps: parsed.childSitemaps,
+        warnings,
+    };
+}
+/** Generate an XML sitemap from a list of URLs. */
+export function generateSitemap(entries) {
+    const lines = [
+        '<?xml version="1.0" encoding="UTF-8"?>',
+        '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+    ];
+    for (const entry of entries) {
+        lines.push("  <url>");
+        lines.push(`    <loc>${escapeXml(entry.loc)}</loc>`);
+        if (entry.lastmod) {
+            lines.push(`    <lastmod>${escapeXml(entry.lastmod)}</lastmod>`);
+        }
+        if (entry.changefreq) {
+            lines.push(`    <changefreq>${escapeXml(entry.changefreq)}</changefreq>`);
+        }
+        if (entry.priority !== undefined) {
+            lines.push(`    <priority>${entry.priority.toFixed(1)}</priority>`);
+        }
+        lines.push("  </url>");
+    }
+    lines.push("</urlset>");
+    return lines.join("\n");
+}
+function escapeXml(str) {
+    return str
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Technical SEO audit analyzer.
+ *
+ * Ported from the Python `seo-technical/SKILL.md` directives in claude-seo.
+ * Audits crawlability, indexability, security, URL structure, mobile,
+ * and AI crawler management — all using local HTTP fetches only.
+ */
+import type { SeoConfig } from "../config.js";
+import type { FetchResult, PageData, TechnicalAuditResult } from "../types.js";
+export declare function auditTechnical(url: string, config: SeoConfig, pageData?: PageData, fetchResult?: FetchResult): Promise<TechnicalAuditResult>;
+//# sourceMappingURL=technical.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"technical.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/analyzers/technical.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAc,WAAW,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AA2D3F,wBAAsB,cAAc,CAClC,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,SAAS,EACjB,QAAQ,CAAC,EAAE,QAAQ,EACnB,WAAW,CAAC,EAAE,WAAW,GACxB,OAAO,CAAC,oBAAoB,CAAC,CA+N/B"}