@aexol/spectral 0.9.42 → 0.9.43

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

@@ -0,0 +1,268 @@
+import { fetchPage, fetchRobotsTxt } from "../utils/fetcher.js";
+import { parsePage } from "../utils/parser.js";
+const AI_CRAWLER_TOKENS = [
+    "GPTBot",
+    "ChatGPT-User",
+    "ClaudeBot",
+    "PerplexityBot",
+    "Bytespider",
+    "Google-Extended",
+    "CCBot",
+];
+function parseRobotsTxt(content) {
+    const lines = content.split("\n").map((l) => l.trim());
+    let sitemapDeclared = false;
+    const aiCrawlerRules = [];
+    let currentUserAgents = [];
+    for (const line of lines) {
+        if (!line || line.startsWith("#"))
+            continue;
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim().toLowerCase();
+        const value = line.slice(colonIdx + 1).trim();
+        if (key === "user-agent") {
+            currentUserAgents.push(value);
+        }
+        else if (key === "disallow" || key === "allow") {
+            for (const ua of currentUserAgents) {
+                if (AI_CRAWLER_TOKENS.includes(ua)) {
+                    aiCrawlerRules.push(`${ua}: ${key} ${value}`);
+                }
+            }
+        }
+        else if (key === "sitemap") {
+            sitemapDeclared = true;
+        }
+        // Reset user-agents when we hit a non-user-agent line after a group.
+        if (key !== "user-agent") {
+            currentUserAgents = [];
+        }
+    }
+    return { sitemapDeclared, aiCrawlerRules };
+}
+const SECURITY_HEADERS = [
+    "content-security-policy",
+    "strict-transport-security",
+    "x-frame-options",
+    "x-content-type-options",
+    "referrer-policy",
+    "permissions-policy",
+];
+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
+    }
+    const robotsContent = robotsResult?.statusCode === 200 ? robotsResult.content : "";
+    const robotsParsed = robotsContent ? parseRobotsTxt(robotsContent) : { sitemapDeclared: false, aiCrawlerRules: [] };
+    // --- Crawlability ---
+    let crawlScore = 100;
+    if (robotsResult?.statusCode !== 200) {
+        crawlScore -= 30;
+        issues.push({
+            category: "Crawlability",
+            severity: "high",
+            title: "robots.txt not found or inaccessible",
+            description: `robots.txt returned status ${robotsResult?.statusCode ?? "N/A"}.`,
+            recommendation: "Create a robots.txt file at the site root with appropriate directives.",
+        });
+    }
+    if (!robotsParsed.sitemapDeclared) {
+        crawlScore -= 15;
+        issues.push({
+            category: "Crawlability",
+            severity: "medium",
+            title: "Sitemap not declared in robots.txt",
+            description: "No Sitemap directive found in robots.txt.",
+            recommendation: "Add 'Sitemap: https://example.com/sitemap.xml' to robots.txt.",
+        });
+    }
+    categoryScores["Crawlability"] = Math.max(0, crawlScore);
+    // --- Indexability ---
+    let indexScore = 100;
+    if (pageData.metaRobots?.toLowerCase().includes("noindex")) {
+        indexScore -= 40;
+        issues.push({
+            category: "Indexability",
+            severity: "critical",
+            title: "Page is blocked from indexing (noindex)",
+            description: `meta robots contains 'noindex': ${pageData.metaRobots}`,
+            recommendation: "Remove the noindex directive if this page should be indexed.",
+        });
+    }
+    if (pageData.h1Count === 0) {
+        indexScore -= 15;
+        issues.push({
+            category: "Indexability",
+            severity: "medium",
+            title: "Missing H1 heading",
+            description: "The page has no H1 element.",
+            recommendation: "Add a single, descriptive H1 heading to the page.",
+        });
+    }
+    if (pageData.h1Count > 1) {
+        indexScore -= 10;
+        issues.push({
+            category: "Indexability",
+            severity: "low",
+            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.",
+        });
+    }
+    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 {
+        indexScore -= 10;
+        issues.push({
+            category: "Indexability",
+            severity: "medium",
+            title: "Missing canonical tag",
+            description: "No canonical link tag found.",
+            recommendation: "Add a self-referencing canonical tag to prevent duplicate content issues.",
+        });
+    }
+    categoryScores["Indexability"] = Math.max(0, indexScore);
+    // --- Security ---
+    let securityScore = 100;
+    const isHttps = fetchResult.finalUrl.startsWith("https://");
+    if (!isHttps) {
+        securityScore -= 50;
+        issues.push({
+            category: "Security",
+            severity: "critical",
+            title: "Site is not served over HTTPS",
+            description: "The page is served over HTTP, not HTTPS.",
+            recommendation: "Install an SSL certificate and redirect all HTTP traffic to HTTPS.",
+        });
+    }
+    const securityHeaders = {};
+    for (const header of SECURITY_HEADERS) {
+        securityHeaders[header] = fetchResult.headers[header] ?? null;
+        if (!securityHeaders[header]) {
+            securityScore -= 10;
+            issues.push({
+                category: "Security",
+                severity: "medium",
+                title: `Missing security header: ${header}`,
+                description: `The ${header} response header is not set.`,
+                recommendation: `Configure the ${header} header on the web server.`,
+            });
+        }
+    }
+    categoryScores["Security"] = Math.max(0, securityScore);
+    // --- URL Structure ---
+    let urlScore = 100;
+    if (fetchResult.finalUrl.length > 100) {
+        urlScore -= 10;
+        issues.push({
+            category: "URL Structure",
+            severity: "low",
+            title: "URL is longer than 100 characters",
+            description: `URL length: ${fetchResult.finalUrl.length}`,
+            recommendation: "Shorten the URL where possible for better readability and SEO.",
+        });
+    }
+    if (fetchResult.redirectChain.length > 1) {
+        urlScore -= 15;
+        issues.push({
+            category: "URL Structure",
+            severity: "medium",
+            title: "Redirect chain detected",
+            description: `${fetchResult.redirectChain.length} redirects before reaching the final URL.`,
+            recommendation: "Reduce redirect chains to a single hop (max 1 redirect).",
+        });
+    }
+    // Check for uppercase in path.
+    try {
+        const path = new URL(fetchResult.finalUrl).pathname;
+        if (path !== path.toLowerCase() && path.match(/[A-Z]/)) {
+            urlScore -= 5;
+            issues.push({
+                category: "URL Structure",
+                severity: "low",
+                title: "URL contains uppercase characters",
+                description: `Path: ${path}`,
+                recommendation: "Use lowercase URLs for consistency.",
+            });
+        }
+    }
+    catch {
+        // ignore
+    }
+    categoryScores["URL Structure"] = Math.max(0, urlScore);
+    // --- Mobile Optimization ---
+    let mobileScore = 100;
+    const mobileOptimized = !!pageData.viewport;
+    if (!mobileOptimized) {
+        mobileScore -= 50;
+        issues.push({
+            category: "Mobile",
+            severity: "critical",
+            title: "Missing viewport meta tag",
+            description: "No viewport meta tag found. Mobile-first indexing requires responsive design.",
+            recommendation: 'Add <meta name="viewport" content="width=device-width, initial-scale=1"> to the <head>.',
+        });
+    }
+    categoryScores["Mobile"] = Math.max(0, mobileScore);
+    // --- AI Crawler Management ---
+    let aiScore = 100;
+    if (robotsParsed.aiCrawlerRules.length === 0) {
+        // Not an error, but an opportunity.
+        aiScore -= 0;
+        issues.push({
+            category: "AI Crawlers",
+            severity: "low",
+            title: "No AI crawler directives in robots.txt",
+            description: "No rules found for GPTBot, ClaudeBot, Google-Extended, or other AI crawlers.",
+            recommendation: "Consider your AI visibility strategy — block or allow AI training crawlers explicitly.",
+        });
+    }
+    categoryScores["AI Crawlers"] = aiScore;
+    // --- Overall score ---
+    const scores = Object.values(categoryScores);
+    const overallScore = scores.length > 0
+        ? Math.round(scores.reduce((a, b) => a + b, 0) / scores.length)
+        : 0;
+    return {
+        url: fetchResult.finalUrl,
+        score: overallScore,
+        issues,
+        categoryScores,
+        robotsTxt: {
+            exists: robotsResult?.statusCode === 200,
+            sitemapDeclared: robotsParsed.sitemapDeclared,
+            aiCrawlerRules: robotsParsed.aiCrawlerRules,
+            content: robotsContent || undefined,
+        },
+        securityHeaders,
+        isHttps,
+        mobileOptimized,
+    };
+}

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

@@ -0,0 +1,24 @@
+export interface SeoConfig {
+    /** Default request timeout in milliseconds. */
+    timeout: number;
+    /** Default User-Agent string for HTTP requests. */
+    userAgent: string;
+    /** User-Agent used when impersonating Googlebot. */
+    googlebotUserAgent: string;
+    /** Whether to follow HTTP redirects by default. */
+    followRedirects: boolean;
+    /** Maximum number of redirects to follow. */
+    maxRedirects: number;
+    /** Directory for SEO report output. */
+    outputDir: string;
+    /** Path to the drift-monitoring SQLite database. */
+    dbPath: string;
+    /** Default viewport for rendering. */
+    defaultViewport: "desktop" | "mobile";
+    /** Block resource types during rendering to speed up fetches. */
+    blockRenderResources: string[];
+    /** Whether SSRF protection is enabled (blocks private/internal IPs). */
+    ssrfProtection: boolean;
+}
+export declare function loadSeoConfig(): SeoConfig;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +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"}

package/dist/extensions/seo/config.js

@@ -0,0 +1,48 @@
+/**
+ * Configuration for the SEO extension.
+ *
+ * All values are environment-variable driven with sensible defaults so the
+ * extension works out-of-the-box without any setup.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+function envBool(key, def) {
+    const v = process.env[key];
+    if (v === undefined)
+        return def;
+    return v === "1" || v.toLowerCase() === "true" || v.toLowerCase() === "yes";
+}
+function envInt(key, def) {
+    const v = process.env[key];
+    if (v === undefined)
+        return def;
+    const n = Number.parseInt(v, 10);
+    return Number.isNaN(n) ? def : n;
+}
+function envList(key, def) {
+    const v = process.env[key];
+    if (!v)
+        return def;
+    return v
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+const DEFAULT_USER_AGENT = "Mozilla/5.0 (compatible; SpectralSEOBot/1.0; +https://aexol.com)";
+const GOOGLEBOT_UA = "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)";
+export function loadSeoConfig() {
+    const home = homedir();
+    const spectralDir = process.env.SPECTRAL_CONFIG_DIR ?? join(home, ".spectral");
+    return {
+        timeout: envInt("SEO_TIMEOUT", 30_000),
+        userAgent: process.env.SEO_USER_AGENT ?? DEFAULT_USER_AGENT,
+        googlebotUserAgent: process.env.SEO_GOOGLEBOT_UA ?? GOOGLEBOT_UA,
+        followRedirects: envBool("SEO_FOLLOW_REDIRECTS", true),
+        maxRedirects: envInt("SEO_MAX_REDIRECTS", 10),
+        outputDir: process.env.SEO_OUTPUT_DIR ?? join(spectralDir, "seo-reports"),
+        dbPath: process.env.SEO_DB_PATH ?? join(spectralDir, "seo", "drift.db"),
+        defaultViewport: process.env.SEO_VIEWPORT ?? "desktop",
+        blockRenderResources: envList("SEO_BLOCK_RESOURCES", ["image", "font", "stylesheet"]),
+        ssrfProtection: envBool("SEO_SSRF_PROTECTION", true),
+    };
+}

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

@@ -0,0 +1,16 @@
+/**
+ * SEO Analysis extension — native TypeScript SEO audit tools.
+ *
+ * Provides offline-first SEO analysis with no external API keys required.
+ * Covers: on-page parsing, technical audits, content quality, Schema.org
+ * detection/generation, sitemap analysis/generation, image audits, preload/
+ * bfcache audits, agent UX audits, parasite-SEO risk scanning, drift
+ * monitoring, and full audit orchestration with report generation.
+ *
+ * Ported from AgriciDaniel/claude-seo — only components that don't require
+ * external service integrations (PageSpeed API, GSC, GA4, DataForSEO, etc.)
+ * are included.
+ */
+import type { ExtensionAPI } from "../../sdk/coding-agent/index.js";
+export default function seoExtension(ext: ExtensionAPI): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/extensions/seo/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAC;AAkBpE,wBAA8B,YAAY,CAAC,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CA+C3E"}

package/dist/extensions/seo/index.js

@@ -0,0 +1,88 @@
+import { loadSeoConfig } from "./config.js";
+import { closeRenderer } from "./utils/renderer.js";
+import { closeDriftDb } from "./analyzers/drift.js";
+import { registerFetchTools } from "./tools/fetch.js";
+import { registerParseTools } from "./tools/parse.js";
+import { registerTechnicalTools } from "./tools/technical.js";
+import { registerContentTools } from "./tools/content.js";
+import { registerSchemaTools } from "./tools/schema.js";
+import { registerSitemapTools } from "./tools/sitemap.js";
+import { registerImageTools } from "./tools/images.js";
+import { registerPreloadTools } from "./tools/preload.js";
+import { registerAgentUxTools } from "./tools/agent-ux.js";
+import { registerParasiteTools } from "./tools/parasite.js";
+import { registerDriftTools } from "./tools/drift.js";
+import { registerFullAuditTools } from "./tools/full-audit.js";
+import { registerReportTools } from "./tools/report.js";
+export default async function seoExtension(ext) {
+    const config = loadSeoConfig();
+    // Clean up resources on session shutdown.
+    ext.on("session_shutdown", async () => {
+        try {
+            await closeRenderer();
+            closeDriftDb();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[seo] Error during cleanup: ${msg}\n`);
+        }
+    });
+    const registrars = [
+        { name: "fetch", fn: () => registerFetchTools(ext, config) },
+        { name: "parse", fn: () => registerParseTools(ext, config) },
+        { name: "technical", fn: () => registerTechnicalTools(ext, config) },
+        { name: "content", fn: () => registerContentTools(ext, config) },
+        { name: "schema", fn: () => registerSchemaTools(ext, config) },
+        { name: "sitemap", fn: () => registerSitemapTools(ext, config) },
+        { name: "images", fn: () => registerImageTools(ext, config) },
+        { name: "preload", fn: () => registerPreloadTools(ext, config) },
+        { name: "agent-ux", fn: () => registerAgentUxTools(ext, config) },
+        { name: "parasite", fn: () => registerParasiteTools(ext, config) },
+        { name: "drift", fn: () => registerDriftTools(ext, config) },
+        { name: "full-audit", fn: () => registerFullAuditTools(ext, config) },
+        { name: "report", fn: () => registerReportTools(ext, config) },
+    ];
+    let totalRegistered = 0;
+    for (const registrar of registrars) {
+        try {
+            const before = countSeoTools(ext);
+            registrar.fn();
+            const after = countSeoTools(ext);
+            totalRegistered += after - before;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stderr.write(`[seo] Failed to register ${registrar.name} tools: ${msg}\n`);
+        }
+    }
+    process.stderr.write(`[seo] Registered ${totalRegistered} SEO analysis tool(s). ` +
+        `Output dir: ${config.outputDir}, Drift DB: ${config.dbPath}.\n`);
+}
+const SEO_TOOL_NAMES = [
+    "seo_fetch",
+    "seo_render",
+    "seo_parse_page",
+    "seo_technical_audit",
+    "seo_content_quality",
+    "seo_schema_audit",
+    "seo_schema_generate",
+    "seo_sitemap_analyze",
+    "seo_sitemap_generate",
+    "seo_image_audit",
+    "seo_preload_audit",
+    "seo_agent_ux_audit",
+    "seo_parasite_risk",
+    "seo_drift_baseline",
+    "seo_drift_compare",
+    "seo_drift_history",
+    "seo_audit",
+    "seo_report",
+];
+function countSeoTools(ext) {
+    let count = 0;
+    for (const name of SEO_TOOL_NAMES) {
+        if (ext.getToolDefinition(name))
+            count++;
+    }
+    return count;
+}

package/dist/extensions/seo/tools/agent-ux.d.ts

@@ -0,0 +1,7 @@
+/**
+ * seo_agent_ux_audit tool — AI-agent friendliness audit.
+ */
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import type { SeoConfig } from "../config.js";
+export declare function registerAgentUxTools(ext: ExtensionAPI, config: SeoConfig): void;
+//# sourceMappingURL=agent-ux.d.ts.map

package/dist/extensions/seo/tools/agent-ux.d.ts.map

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

package/dist/extensions/seo/tools/agent-ux.js

@@ -0,0 +1,63 @@
+import { auditAgentUx } from "../analyzers/agent-ux.js";
+import { renderPage, isRendererAvailable } from "../utils/renderer.js";
+import { errorResult, textResult } from "./helpers.js";
+export function registerAgentUxTools(ext, config) {
+    const agentUxTool = {
+        name: "seo_agent_ux_audit",
+        label: "SEO Agent UX Audit",
+        description: "Audit a page for AI-agent friendliness using Playwright's accessibility tree and semantic HTML analysis. " +
+            "Checks: real <button>/<a> vs <div onclick> widgets, semantic landmarks (header/nav/main/footer), " +
+            "inputs without labels, unnamed interactive elements in the accessibility tree, and role='generic' ratio. " +
+            "Returns a 0-100 Agent-UX score and improvement opportunities. Requires Playwright Chromium.",
+        promptSnippet: "`seo_agent_ux_audit { url, viewport? }` — audit AI-agent friendliness (a11y tree + semantic HTML)",
+        parameters: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "The URL to audit." },
+                viewport: {
+                    type: "string",
+                    enum: ["desktop", "mobile"],
+                    description: "Viewport size. Default: 'desktop'.",
+                },
+            },
+            required: ["url"],
+        },
+        async execute(_toolCallId, params) {
+            const { url, viewport } = params;
+            const available = await isRendererAvailable();
+            if (!available) {
+                return errorResult("Playwright Chromium is not available. Install it with: npx playwright install chromium");
+            }
+            try {
+                const renderResult = await renderPage(url, config, {
+                    viewport,
+                    captureA11y: true,
+                    captureConsole: false,
+                });
+                if (renderResult.error) {
+                    return errorResult(`Render failed: ${renderResult.error}`);
+                }
+                const audit = auditAgentUx(renderResult);
+                const summary = `✓ Agent UX Audit: ${renderResult.finalUrl}\n` +
+                    `Agent-UX Score: ${audit.agentUxScore}/100\n\n` +
+                    `HTML Analysis:\n` +
+                    `  Real <button>: ${audit.html.realButtons}\n` +
+                    `  Real <a href>: ${audit.html.realAnchors}\n` +
+                    `  <div onclick> widgets: ${audit.html.divOnclickWidgets} ${audit.html.divOnclickWidgets > 0 ? "⚠️" : "✓"}\n` +
+                    `  Semantic landmarks: ${audit.html.semanticLandmarks}\n` +
+                    `  Inputs missing labels: ${audit.html.inputsMissingLabel}/${audit.html.inputsTotal}\n\n` +
+                    `Accessibility Tree:\n` +
+                    `  Total nodes: ${audit.accessibilityTree.totalNodes}\n` +
+                    `  Interactive nodes: ${audit.accessibilityTree.interactiveNodes}\n` +
+                    `  Unnamed interactive: ${audit.accessibilityTree.unnamedInteractive} ${audit.accessibilityTree.unnamedInteractive > 0 ? "⚠️" : "✓"}\n` +
+                    `  role="generic" ratio: ${(audit.accessibilityTree.roleGenericRatio * 100).toFixed(0)}%\n\n` +
+                    `Opportunities:\n${audit.opportunities.map((o) => `  • ${o}`).join("\n") || "  (none)"}`;
+                return textResult(summary, { audit });
+            }
+            catch (err) {
+                return errorResult(err instanceof Error ? err.message : String(err));
+            }
+        },
+    };
+    ext.registerTool(agentUxTool);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * seo_content_quality tool — heuristic content quality analysis.
+ */
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import type { SeoConfig } from "../config.js";
+export declare function registerContentTools(ext: ExtensionAPI, config: SeoConfig): void;
+//# sourceMappingURL=content.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,55 @@
+import { analyzeContentQuality } from "../analyzers/content.js";
+import { fetchPage } from "../utils/fetcher.js";
+import { extractText } from "../utils/parser.js";
+import { errorResult, textResult } from "./helpers.js";
+export function registerContentTools(ext, config) {
+    const contentTool = {
+        name: "seo_content_quality",
+        label: "SEO Content Quality",
+        description: "Analyze content quality using QRG-aligned heuristics: filler phrase detection, AI-pattern detection, " +
+            "information density (entities and numbers per token), repetition scoring, and an overall quality composite. " +
+            "Accepts either a URL (fetches and extracts text) or raw text. No external API calls — pure heuristics.",
+        promptSnippet: "`seo_content_quality { url? | text? }` — analyze content quality (filler, AI patterns, density)",
+        parameters: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "URL to fetch and analyze. If provided, text is extracted from the page." },
+                text: { type: "string", description: "Raw text to analyze. Used if 'url' is not provided." },
+            },
+        },
+        async execute(_toolCallId, params) {
+            const { url, text } = params;
+            try {
+                let content = text ?? "";
+                let effectiveUrl;
+                if (url && !text) {
+                    const result = await fetchPage(url, config);
+                    if (result.error) {
+                        return errorResult(`Fetch failed: ${result.error}`);
+                    }
+                    content = extractText(result.content);
+                    effectiveUrl = result.finalUrl;
+                }
+                if (!content) {
+                    return errorResult("Either 'url' or 'text' must be provided.");
+                }
+                const result = analyzeContentQuality(content, effectiveUrl);
+                const summary = `✓ Content Quality Analysis${effectiveUrl ? `: ${effectiveUrl}` : ""}\n` +
+                    `Word Count: ${result.wordCount}\n` +
+                    `Overall Quality: ${result.overallQuality}/100\n\n` +
+                    `Filler Score: ${result.fillerScore}/100 ${result.fillerScore > 30 ? "⚠️" : "✓"}\n` +
+                    `AI Pattern Score: ${result.aiPatternScore}/100 ${result.aiPatternScore > 30 ? "⚠️" : "✓"}\n` +
+                    `Information Density: ${result.informationDensity}/100 ${result.informationDensity < 10 ? "⚠️" : "✓"}\n` +
+                    `Repetition Score: ${result.repetitionScore}/100 ${result.repetitionScore > 40 ? "⚠️" : "✓"}\n\n` +
+                    `Flags: ${result.flags.length > 0 ? result.flags.join(", ") : "none"}\n` +
+                    `Filler matches: ${result.fillerMatches.length > 0 ? result.fillerMatches.slice(0, 5).join(", ") : "none"}\n` +
+                    `AI pattern matches: ${result.aiPatternMatches.length > 0 ? result.aiPatternMatches.slice(0, 5).join(", ") : "none"}`;
+                return textResult(summary, { result });
+            }
+            catch (err) {
+                return errorResult(err instanceof Error ? err.message : String(err));
+            }
+        },
+    };
+    ext.registerTool(contentTool);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * seo_drift_baseline, seo_drift_compare, seo_drift_history tools.
+ */
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import type { SeoConfig } from "../config.js";
+export declare function registerDriftTools(ext: ExtensionAPI, config: SeoConfig): void;
+//# sourceMappingURL=drift.d.ts.map

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

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