@aexol/spectral 0.9.42 → 0.9.44

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

@@ -0,0 +1,193 @@
+import { auditTechnical } from "../analyzers/technical.js";
+import { analyzeContentQuality } from "../analyzers/content.js";
+import { fetchPage } from "../utils/fetcher.js";
+import { parsePage, extractText } from "../utils/parser.js";
+import { analyzeKeywords } from "../analyzers/keywords.js";
+import { analyzeReadability } from "../analyzers/readability.js";
+import { errorResult, textResult, truncate } from "./helpers.js";
+export function registerBatchTools(ext, config) {
+    // === seo_audit_batch ===
+    const batchTool = {
+        name: "seo_audit_batch",
+        label: "SEO Batch Audit",
+        description: "Run SEO audits on multiple URLs, typically from a sitemap. " +
+            "Audits each URL for technical SEO, content quality, and schema markup. " +
+            "Returns a comparison table with scores for each page. " +
+            "Use this after seo_crawl to audit all discovered subpages at once.",
+        promptSnippet: "`seo_audit_batch { urls[] }` — audit multiple URLs and compare scores",
+        parameters: {
+            type: "object",
+            properties: {
+                urls: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "List of URLs to audit.",
+                },
+                maxPages: {
+                    type: "number",
+                    description: "Max URLs to audit (limits batch size). Default: 20.",
+                },
+            },
+            required: ["urls"],
+        },
+        async execute(_toolCallId, params) {
+            const { urls, maxPages } = params;
+            try {
+                const toAudit = urls.slice(0, maxPages ?? 20);
+                const results = [];
+                for (const url of toAudit) {
+                    try {
+                        const fetchResult = await fetchPage(url, 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);
+                        results.push({
+                            url: fetchResult.finalUrl,
+                            status: fetchResult.statusCode,
+                            technicalScore: technical.score,
+                            contentScore: content.overallQuality,
+                            title: pageData.title ?? "(no title)",
+                            wordCount: pageData.wordCount,
+                        });
+                    }
+                    catch (err) {
+                        results.push({
+                            url,
+                            status: 0,
+                            technicalScore: 0,
+                            contentScore: 0,
+                            title: "(error)",
+                            wordCount: 0,
+                            error: err instanceof Error ? err.message : String(err),
+                        });
+                    }
+                }
+                const avgTech = Math.round(results.filter((r) => !r.error).reduce((s, r) => s + r.technicalScore, 0) /
+                    Math.max(1, results.filter((r) => !r.error).length));
+                const avgContent = Math.round(results.filter((r) => !r.error).reduce((s, r) => s + r.contentScore, 0) /
+                    Math.max(1, results.filter((r) => !r.error).length));
+                const lines = [
+                    `✓ Batch Audit: ${results.length} pages`,
+                    ``,
+                    `Average Technical Score: ${avgTech}/100`,
+                    `Average Content Score: ${avgContent}/100`,
+                    ``,
+                    `| # | URL | Status | Tech | Content | Title |`,
+                    `|---|-----|--------|------|---------|-------|`,
+                ];
+                results.forEach((r, i) => {
+                    lines.push(`| ${i + 1} | ${truncate(r.url, 60)} | ${r.status || "ERR"} | ${r.technicalScore} | ${r.contentScore} | ${truncate(r.title, 40)} |`);
+                });
+                return textResult(lines.join("\n"), { results, avgTech, avgContent });
+            }
+            catch (err) {
+                return errorResult(err instanceof Error ? err.message : String(err));
+            }
+        },
+    };
+    // === seo_competitor_gap ===
+    const gapTool = {
+        name: "seo_competitor_gap",
+        label: "SEO Competitor Gap Analysis",
+        description: "Compare your page against a competitor's page. Analyzes differences in: " +
+            "keyword usage (which keywords do they use that you don't?), content length, " +
+            "readability, heading structure, schema markup, and technical signals. " +
+            "Helps identify content gaps and optimization opportunities.",
+        promptSnippet: "`seo_competitor_gap { yourUrl, competitorUrl }` — compare pages for content/SEO gaps",
+        parameters: {
+            type: "object",
+            properties: {
+                yourUrl: { type: "string", description: "Your page URL." },
+                competitorUrl: { type: "string", description: "Competitor page URL to compare against." },
+            },
+            required: ["yourUrl", "competitorUrl"],
+        },
+        async execute(_toolCallId, params) {
+            const { yourUrl, competitorUrl } = params;
+            try {
+                const [yourFetch, compFetch] = await Promise.all([
+                    fetchPage(yourUrl, config),
+                    fetchPage(competitorUrl, config),
+                ]);
+                const yourData = parsePage(yourFetch.content, yourFetch.finalUrl);
+                const compData = parsePage(compFetch.content, compFetch.finalUrl);
+                const yourText = extractText(yourFetch.content);
+                const compText = extractText(compFetch.content);
+                const yourKw = analyzeKeywords(yourText, yourData.url);
+                const compKw = analyzeKeywords(compText, compData.url);
+                const yourReadability = analyzeReadability(yourText, yourData.url);
+                const compReadability = analyzeReadability(compText, compData.url);
+                // Find keywords competitor uses that you don't
+                const yourKeywordSet = new Set(yourKw.keywords.map((k) => k.keyword));
+                const compKeywordSet = new Set(compKw.keywords.map((k) => k.keyword));
+                const competitorOnlyKeywords = compKw.keywords
+                    .filter((k) => !yourKeywordSet.has(k.keyword))
+                    .slice(0, 10);
+                const sharedKeywords = compKw.keywords
+                    .filter((k) => yourKeywordSet.has(k.keyword))
+                    .slice(0, 10);
+                const yourSchemaTypes = new Set(yourData.schemaBlocks.map((s) => s.type));
+                const compSchemaTypes = new Set(compData.schemaBlocks.map((s) => s.type));
+                const compOnlySchemas = [...compSchemaTypes].filter((t) => !yourSchemaTypes.has(t));
+                const lines = [
+                    `✓ Competitor Gap Analysis`,
+                    ``,
+                    `Your page:       ${yourData.url}`,
+                    `Competitor:      ${compData.url}`,
+                    ``,
+                    `## Content Comparison`,
+                    ``,
+                    `| Metric | Yours | Competitor |`,
+                    `|--------|-------|------------|`,
+                    `| Word count | ${yourData.wordCount} | ${compData.wordCount} |`,
+                    `| Headings | H1:${yourData.h1Count} H2:${yourData.h2Count} H3:${yourData.h3Count} | H1:${compData.h1Count} H2:${compData.h2Count} H3:${compData.h3Count} |`,
+                    `| Internal links | ${yourData.internalLinkCount} | ${compData.internalLinkCount} |`,
+                    `| Images | ${yourData.images.length} | ${compData.images.length} |`,
+                    `| Schema types | ${yourData.schemaBlocks.length} | ${compData.schemaBlocks.length} |`,
+                    `| Readability (grade) | ${yourReadability.gradeAverage} | ${compReadability.gradeAverage} |`,
+                    `| Readability (ease) | ${yourReadability.fleschReadingEase} | ${compReadability.fleschReadingEase} |`,
+                    ``,
+                ];
+                if (competitorOnlyKeywords.length > 0) {
+                    lines.push(`## Keywords Competitor Uses That You Don't`, ``, ...competitorOnlyKeywords.map((k) => `  • "${k.keyword}" — ${k.count}x, density ${k.density}%, TF-IDF ${k.tfidf}`), ``);
+                }
+                if (sharedKeywords.length > 0) {
+                    lines.push(`## Shared Keywords`, ``, ...sharedKeywords.map((k) => `  • "${k.keyword}" — you: ${yourKw.keywords.find((yk) => yk.keyword === k.keyword)?.count ?? 0}x, competitor: ${k.count}x`), ``);
+                }
+                if (compOnlySchemas.length > 0) {
+                    lines.push(`## Schema Types Competitor Has That You Don't`, ``, ...compOnlySchemas.map((t) => `  • ${t}`), ``);
+                }
+                // Content gap recommendations
+                lines.push(`## Recommendations`);
+                if (compData.wordCount > yourData.wordCount * 1.5) {
+                    lines.push(`  • Content gap: Competitor has ${compData.wordCount - yourData.wordCount} more words. Consider expanding your content.`);
+                }
+                if (compData.h2Count > yourData.h2Count) {
+                    lines.push(`  • Structure gap: Competitor uses more H2 subheadings (${compData.h2Count} vs ${yourData.h2Count}). Break your content into more sections.`);
+                }
+                if (compData.schemaBlocks.length > yourData.schemaBlocks.length) {
+                    lines.push(`  • Schema gap: Competitor has ${compData.schemaBlocks.length - yourData.schemaBlocks.length} more schema types. Consider adding: ${compOnlySchemas.join(", ")}`);
+                }
+                if (competitorOnlyKeywords.length > 0) {
+                    lines.push(`  • Keyword gap: Competitor ranks for ${competitorOnlyKeywords.length} keywords you don't cover. Consider addressing: ${competitorOnlyKeywords.map((k) => `"${k.keyword}"`).join(", ")}`);
+                }
+                if (lines[lines.length - 1] === `## Recommendations`) {
+                    lines.push(`  • No significant gaps detected. Your content appears competitive.`);
+                }
+                return textResult(lines.join("\n"), {
+                    yourUrl: yourData.url,
+                    competitorUrl: compData.url,
+                    competitorOnlyKeywords,
+                    sharedKeywords,
+                    compOnlySchemas,
+                });
+            }
+            catch (err) {
+                return errorResult(err instanceof Error ? err.message : String(err));
+            }
+        },
+    };
+    ext.registerTool(batchTool);
+    ext.registerTool(gapTool);
+}

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

@@ -0,0 +1,4 @@
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import type { SeoConfig } from "../config.js";
+export declare function registerCrawlTools(ext: ExtensionAPI, config: SeoConfig): void;
+//# sourceMappingURL=crawl.d.ts.map

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

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

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

@@ -0,0 +1,166 @@
+import { crawlSite } from "../analyzers/crawler.js";
+import { errorResult, textResult, truncate } from "./helpers.js";
+export function registerCrawlTools(ext, config) {
+    const crawlTool = {
+        name: "seo_crawl",
+        label: "SEO Site Crawler",
+        description: "Crawl an entire website starting from a URL, following internal links up to a configurable depth and page limit. " +
+            "Discovers all subpages, builds an internal link graph, detects broken links (4xx/5xx), " +
+            "finds duplicate content (same title/description/H1 across pages), and identifies orphan pages. " +
+            "Respects robots.txt and rate-limits requests. Returns per-page details and a site-wide summary. " +
+            "Use this before seo_audit to discover all pages, then run seo_audit on key subpages.",
+        promptSnippet: "`seo_crawl { url, maxPages?, maxDepth?, concurrency? }` — crawl a site and discover all subpages, broken links, and duplicate content",
+        promptGuidelines: [
+            "Use seo_crawl to discover all pages on a site before running targeted audits on key subpages.",
+            "The crawler respects robots.txt and rate-limits requests automatically.",
+            "Start with maxPages=50 for a quick scan, increase to 200-500 for a full site audit.",
+        ],
+        parameters: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "The starting URL to crawl." },
+                maxPages: { type: "number", description: "Maximum pages to crawl. Default: 200." },
+                maxDepth: { type: "number", description: "Maximum crawl depth from start URL. Default: 5." },
+                concurrency: { type: "number", description: "Concurrent fetches. Default: 3." },
+            },
+            required: ["url"],
+        },
+        async execute(_toolCallId, params) {
+            const { url, maxPages, maxDepth, concurrency } = params;
+            try {
+                const crawlConfig = {};
+                if (maxPages !== undefined)
+                    crawlConfig.maxPages = maxPages;
+                if (maxDepth !== undefined)
+                    crawlConfig.maxDepth = maxDepth;
+                if (concurrency !== undefined)
+                    crawlConfig.concurrency = concurrency;
+                const result = await crawlSite(url, config, crawlConfig);
+                const summary = formatCrawlSummary(result);
+                return textResult(summary, {
+                    pagesCrawled: result.pagesCrawled,
+                    brokenLinks: result.brokenLinks.length,
+                    duplicateGroups: result.duplicateGroups.length,
+                    orphanPages: result.orphanPages.length,
+                    urls: result.pages.map((p) => p.url),
+                });
+            }
+            catch (err) {
+                return errorResult(err instanceof Error ? err.message : String(err));
+            }
+        },
+    };
+    const crawlReportTool = {
+        name: "seo_crawl_report",
+        label: "SEO Crawl Report",
+        description: "Generate a detailed report from a crawl result. " +
+            "Shows broken links with source pages, duplicate content groups (title/description/H1), " +
+            "orphan pages, link graph statistics, and per-page status codes. " +
+            "Use this after seo_crawl to get actionable insights about site structure problems.",
+        promptSnippet: "`seo_crawl_report { crawlResult }` — generate detailed crawl analysis report",
+        parameters: {
+            type: "object",
+            properties: {
+                crawlResult: {
+                    type: "object",
+                    description: "The CrawlResult object from seo_crawl.",
+                },
+            },
+            required: ["crawlResult"],
+        },
+        async execute(_toolCallId, params) {
+            const { crawlResult } = params;
+            try {
+                const report = generateCrawlReport(crawlResult);
+                return textResult(report, {
+                    pagesCrawled: crawlResult.pagesCrawled,
+                    brokenLinks: crawlResult.brokenLinks.length,
+                    duplicateGroups: crawlResult.duplicateGroups.length,
+                });
+            }
+            catch (err) {
+                return errorResult(err instanceof Error ? err.message : String(err));
+            }
+        },
+    };
+    ext.registerTool(crawlTool);
+    ext.registerTool(crawlReportTool);
+}
+function formatCrawlSummary(result) {
+    const lines = [
+        `✓ Crawl Complete: ${result.baseUrl}`,
+        ``,
+        `Pages crawled: ${result.pagesCrawled}`,
+        `Total pages discovered: ${result.totalPagesFound}`,
+        `Max depth reached: ${result.maxDepthReached}`,
+        `Broken links: ${result.brokenLinks.length}`,
+        `Duplicate content groups: ${result.duplicateGroups.length}`,
+        `Orphan pages: ${result.orphanPages.length}`,
+        `Errors: ${result.errors.length}`,
+        ``,
+        `Crawled URLs (${result.pages.length}):`,
+    ];
+    for (const page of result.pages) {
+        const statusIcon = page.statusCode >= 400 ? "❌" : page.statusCode >= 300 ? "↪" : "✓";
+        const title = page.pageData?.title ?? "(no title)";
+        lines.push(`  ${statusIcon} [${page.statusCode}] depth=${page.depth} ${truncate(page.url, 100)} — ${truncate(title, 60)}`);
+    }
+    if (result.brokenLinks.length > 0) {
+        lines.push(``, `Broken Links (${result.brokenLinks.length}):`);
+        for (const bl of result.brokenLinks) {
+            lines.push(`  ❌ ${bl.targetUrl} → ${bl.statusCode} (from ${bl.sourcePage})`);
+        }
+    }
+    if (result.duplicateGroups.length > 0) {
+        lines.push(``, `Duplicate Content (${result.duplicateGroups.length} groups):`);
+        for (const dg of result.duplicateGroups) {
+            lines.push(`  [${dg.type}] "${truncate(dg.value, 80)}" — ${dg.pageUrls.length} pages`);
+            for (const url of dg.pageUrls.slice(0, 5)) {
+                lines.push(`    • ${url}`);
+            }
+            if (dg.pageUrls.length > 5)
+                lines.push(`    ... and ${dg.pageUrls.length - 5} more`);
+        }
+    }
+    if (result.errors.length > 0) {
+        lines.push(``, `Errors (${result.errors.length}):`);
+        for (const err of result.errors.slice(0, 10)) {
+            lines.push(`  ⚠ ${err}`);
+        }
+    }
+    return lines.join("\n");
+}
+function generateCrawlReport(result) {
+    const lines = [
+        `# SEO Crawl Report`,
+        ``,
+        `**Base URL:** ${result.baseUrl}`,
+        `**Pages crawled:** ${result.pagesCrawled}`,
+        `**Max depth:** ${result.maxDepthReached}`,
+        `**Errors:** ${result.errors.length}`,
+        ``,
+        `## Page Status Summary`,
+        ``,
+        `| URL | Status | Depth | Title |`,
+        `|-----|--------|-------|-------|`,
+        ...result.pages.map((p) => `| ${p.url} | ${p.statusCode} | ${p.depth} | ${truncate(p.pageData?.title ?? "", 50)} |`),
+        ``,
+    ];
+    if (result.brokenLinks.length > 0) {
+        lines.push(`## Broken Links (${result.brokenLinks.length})`, ``, `| Source | Target | Status |`, `|--------|--------|--------|`, ...result.brokenLinks.map((bl) => `| ${bl.sourcePage} | ${bl.targetUrl} | ${bl.statusCode} |`), ``);
+    }
+    if (result.duplicateGroups.length > 0) {
+        lines.push(`## Duplicate Content (${result.duplicateGroups.length} groups)`, ``);
+        for (const dg of result.duplicateGroups) {
+            lines.push(`### ${dg.type.toUpperCase()}: "${truncate(dg.value, 100)}"`, ``, `**${dg.pageUrls.length} pages** share this ${dg.type}:`, ...dg.pageUrls.map((u) => `- ${u}`), ``);
+        }
+    }
+    if (result.linkGraph.length > 0) {
+        const avgInlinks = result.linkGraph.reduce((s, n) => s + n.internalInlinks, 0) / result.linkGraph.length;
+        lines.push(`## Link Graph`, ``, `**Average internal inlinks per page:** ${avgInlinks.toFixed(1)}`, ``, `### Top Pages by Internal Inlinks`, ``, `| URL | Inlinks | Outlinks | Depth |`, `|-----|---------|----------|-------|`, ...result.linkGraph
+            .sort((a, b) => b.internalInlinks - a.internalInlinks)
+            .slice(0, 20)
+            .map((n) => `| ${n.url} | ${n.internalInlinks} | ${n.internalOutlinks} | ${n.depth} |`), ``);
+    }
+    return lines.join("\n");
+}

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"}

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

@@ -0,0 +1,104 @@
+import { captureBaseline, compareBaseline, getBaselineHistory } from "../analyzers/drift.js";
+import { errorResult, textResult } from "./helpers.js";
+export function registerDriftTools(ext, config) {
+    const baselineTool = {
+        name: "seo_drift_baseline",
+        label: "SEO Drift Baseline",
+        description: "Capture an SEO baseline snapshot of a page and store it in a local SQLite database. " +
+            "Records: title, meta description, canonical, robots, H1/H2/H3 headings, schema blocks, Open Graph tags, " +
+            "HTML hash, schema hash, and status code. Use seo_drift_compare later to detect changes. " +
+            "Database path: configured by SEO_DB_PATH (default: ~/.spectral/seo/drift.db).",
+        promptSnippet: "`seo_drift_baseline { url }` — capture an SEO baseline snapshot for drift monitoring",
+        parameters: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "The URL to capture a baseline for." },
+            },
+            required: ["url"],
+        },
+        async execute(_toolCallId, params) {
+            const { url } = params;
+            try {
+                const baseline = await captureBaseline(url, config);
+                const summary = `✓ Baseline captured: ${baseline.url}\n` +
+                    `Baseline ID: ${baseline.id}\n` +
+                    `Timestamp: ${baseline.timestamp}\n` +
+                    `Title: ${baseline.title ?? "(none)"}\n` +
+                    `Canonical: ${baseline.canonical ?? "(none)"}\n` +
+                    `H1: ${baseline.h1 ?? "(none)"}\n` +
+                    `Status Code: ${baseline.statusCode}\n` +
+                    `HTML Hash: ${baseline.htmlHash}\n` +
+                    `Schema Hash: ${baseline.schemaHash}`;
+                return textResult(summary, { baseline });
+            }
+            catch (err) {
+                return errorResult(err instanceof Error ? err.message : String(err));
+            }
+        },
+    };
+    const compareTool = {
+        name: "seo_drift_compare",
+        label: "SEO Drift Compare",
+        description: "Compare a page's current state against a previously captured baseline. " +
+            "Detects changes in: title, meta description, canonical, robots, H1/H2/H3 headings, schema blocks, " +
+            "status code, and HTML hash. Assigns a severity level (none/low/medium/high) based on which fields changed. " +
+            "If baselineId is omitted, compares against the latest baseline for the URL.",
+        promptSnippet: "`seo_drift_compare { url, baselineId? }` — compare current page vs baseline snapshot",
+        parameters: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "The URL to compare." },
+                baselineId: { type: "number", description: "Specific baseline ID to compare against. If omitted, uses the latest." },
+            },
+            required: ["url"],
+        },
+        async execute(_toolCallId, params) {
+            const { url, baselineId } = params;
+            try {
+                const result = await compareBaseline(url, config, baselineId);
+                const summary = `✓ Drift Comparison: ${result.url}\n` +
+                    `Baseline ID: ${result.baselineId} (${result.baselineTimestamp})\n` +
+                    `Compared At: ${result.comparedAt}\n` +
+                    `Severity: ${result.severity.toUpperCase()}\n` +
+                    `Changed Fields (${result.changedFields.length}): ${result.changedFields.join(", ") || "(none)"}`;
+                return textResult(summary, { result });
+            }
+            catch (err) {
+                return errorResult(err instanceof Error ? err.message : String(err));
+            }
+        },
+    };
+    const historyTool = {
+        name: "seo_drift_history",
+        label: "SEO Drift History",
+        description: "List baseline snapshots for a URL, ordered by most recent. " +
+            "Returns baseline IDs, timestamps, titles, and status codes.",
+        promptSnippet: "`seo_drift_history { url, limit? }` — list baseline snapshots for a URL",
+        parameters: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "The URL to get baseline history for." },
+                limit: { type: "number", description: "Maximum number of baselines to return. Default: 20." },
+            },
+            required: ["url"],
+        },
+        async execute(_toolCallId, params) {
+            const { url, limit } = params;
+            try {
+                const history = getBaselineHistory(url, config, limit ?? 20);
+                const summary = `✓ Drift History: ${url}\n` +
+                    `Baselines: ${history.length}\n\n` +
+                    history
+                        .map((b) => `  #${b.id} | ${b.timestamp} | ${b.statusCode} | ${b.title ?? "(no title)"}`)
+                        .join("\n");
+                return textResult(summary, { history });
+            }
+            catch (err) {
+                return errorResult(err instanceof Error ? err.message : String(err));
+            }
+        },
+    };
+    ext.registerTool(baselineTool);
+    ext.registerTool(compareTool);
+    ext.registerTool(historyTool);
+}

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

@@ -0,0 +1,7 @@
+/**
+ * seo_fetch and seo_render tool definitions.
+ */
+import type { ExtensionAPI } from "../../../sdk/coding-agent/index.js";
+import type { SeoConfig } from "../config.js";
+export declare function registerFetchTools(ext: ExtensionAPI, config: SeoConfig): void;
+//# sourceMappingURL=fetch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fetch.d.ts","sourceRoot":"","sources":["../../../../src/extensions/seo/tools/fetch.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,kBAAkB,CAAC,GAAG,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI,CA0I7E"}