0xray 2.0.0

package/dist/mcps/knowledge-skills/seo-consultant.server.js

@@ -0,0 +1,937 @@
+/**
+ * SEO Specialist MCP Server
+ *
+ * Technical SEO optimization for code, content, and technical infrastructure.
+ * Provides schema markup, robots.txt, Core Web Vitals, AI search optimization,
+ * sitemap generation, and deep technical SEO audits.
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { createGracefulShutdown } from "../../utils/shutdown-handler.js";
+class SEOSpecialistServer {
+    server;
+    constructor() {
+        this.server = new Server({ name: "seo-consultant", version: "1.22.67" }, { capabilities: { tools: {} } });
+        this.setupToolHandlers();
+    }
+    setupToolHandlers() {
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: [
+                {
+                    name: "audit-technical-seo",
+                    description: "Perform deep technical SEO audit: schema markup, meta tags, heading structure, internal linking, performance, accessibility, mobile-friendliness",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            targetUrl: { type: "string", description: "Target URL to audit" },
+                            focusAreas: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Areas to focus on (schema, performance, structure, links, accessibility)",
+                            },
+                        },
+                    },
+                },
+                {
+                    name: "generate-schema-markup",
+                    description: "Generate JSON-LD schema markup for: Organization, Product, Article, FAQPage, BreadcrumbList, LocalBusiness, WebSite, HowTo, Recipe, Video, Audio, Course, Event, Person, Book, SoftwareApplication",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            schemaType: {
+                                type: "string",
+                                enum: [
+                                    "Organization",
+                                    "Product",
+                                    "Article",
+                                    "FAQPage",
+                                    "BreadcrumbList",
+                                    "LocalBusiness",
+                                    "WebSite",
+                                    "HowTo",
+                                    "Recipe",
+                                    "VideoObject",
+                                    "AudioObject",
+                                    "Course",
+                                    "Event",
+                                    "Person",
+                                    "Book",
+                                    "SoftwareApplication",
+                                ],
+                            },
+                            data: {
+                                type: "object",
+                                description: "Data to populate schema (varies by type)",
+                            },
+                            includeMicrodata: {
+                                type: "boolean",
+                                description: "Also generate HTML microdata format",
+                                default: false,
+                            },
+                        },
+                        required: ["schemaType", "data"],
+                    },
+                },
+                {
+                    name: "optimize-core-web-vitals",
+                    description: "Analyze and provide optimization recommendations for LCP (Largest Contentful Paint), INP (Interaction to Next Paint), CLS (Cumulative Layout Shift)",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            url: { type: "string", description: "URL to analyze" },
+                            pageType: {
+                                type: "string",
+                                enum: ["homepage", "article", "product", "category", "landing"],
+                                description: "Type of page for context-specific recommendations",
+                            },
+                            currentMetrics: {
+                                type: "object",
+                                description: "Current Core Web Vitals values if known",
+                                properties: {
+                                    LCP: { type: "number" },
+                                    INP: { type: "number" },
+                                    CLS: { type: "number" },
+                                },
+                            },
+                        },
+                        required: ["url"],
+                    },
+                },
+                {
+                    name: "analyze-ai-search",
+                    description: "Optimize content for AI search engines (ChatGPT, Perplexity, Grok, Gemini, Claude). Analyze E-E-A-T signals, structure content for citation",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            content: { type: "string", description: "Content to optimize" },
+                            targetAI: {
+                                type: "array",
+                                items: { type: "string" },
+                                description: "Target AI engines (chatgpt, perplexity, grok, gemini, claude)",
+                            },
+                            pageContext: {
+                                type: "string",
+                                description: "Page context (documentation, blog, product, api)",
+                            },
+                        },
+                        required: ["content"],
+                    },
+                },
+                {
+                    name: "generate-sitemap",
+                    description: "Generate XML sitemap for SEO with proper structure, priorities, and changefreq",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            baseUrl: { type: "string", description: "Base URL for sitemap" },
+                            pages: {
+                                type: "array",
+                                items: {
+                                    type: "object",
+                                    properties: {
+                                        path: { type: "string" },
+                                        lastmod: { type: "string" },
+                                        changefreq: {
+                                            type: "string",
+                                            enum: [
+                                                "always",
+                                                "hourly",
+                                                "daily",
+                                                "weekly",
+                                                "monthly",
+                                                "yearly",
+                                                "never",
+                                            ],
+                                        },
+                                        priority: { type: "number", minimum: 0, maximum: 1 },
+                                    },
+                                },
+                            },
+                            includeImages: { type: "boolean", default: false },
+                            includeVideos: { type: "boolean", default: false },
+                        },
+                        required: ["baseUrl", "pages"],
+                    },
+                },
+                {
+                    name: "optimize-robots-txt",
+                    description: "Optimize robots.txt for SEO best practices, AI crawler optimization, and proper directive structure",
+                    inputSchema: {
+                        type: "object",
+                        properties: {
+                            baseUrl: { type: "string", description: "Site base URL" },
+                            options: {
+                                type: "object",
+                                properties: {
+                                    allowAI: { type: "boolean", description: "Allow AI crawlers", default: true },
+                                    allowSearchBots: {
+                                        type: "boolean",
+                                        description: "Allow standard search bots",
+                                        default: true,
+                                    },
+                                    blockPaths: {
+                                        type: "array",
+                                        items: { type: "string" },
+                                        description: "Paths to disallow",
+                                    },
+                                    crawlDelay: { type: "number", description: "Crawl delay in seconds" },
+                                    generateSitemapDirective: { type: "boolean", default: true },
+                                },
+                            },
+                        },
+                        required: ["baseUrl"],
+                    },
+                },
+            ],
+        }));
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args = {} } = request.params;
+            try {
+                switch (name) {
+                    case "audit-technical-seo":
+                        return this.auditTechnicalSEO(args);
+                    case "generate-schema-markup":
+                        return this.generateSchemaMarkup(args);
+                    case "optimize-core-web-vitals":
+                        return this.optimizeCoreWebVitals(args);
+                    case "analyze-ai-search":
+                        return this.analyzeAISearch(args);
+                    case "generate-sitemap":
+                        return this.generateSitemap(args);
+                    case "optimize-robots-txt":
+                        return this.optimizeRobotsTxt(args);
+                    default:
+                        throw new Error(`Unknown tool: ${name}`);
+                }
+            }
+            catch (error) {
+                return {
+                    content: [{ type: "text", text: `Error: ${error}` }],
+                    isError: true,
+                };
+            }
+        });
+    }
+    auditTechnicalSEO(args) {
+        const targetUrl = args.targetUrl || "https://example.com";
+        const focusAreas = args.focusAreas || [
+            "schema",
+            "performance",
+            "structure",
+            "links",
+            "accessibility",
+        ];
+        const issues = [];
+        const recommendations = [];
+        const metrics = {};
+        for (const area of focusAreas) {
+            switch (area) {
+                case "schema":
+                    issues.push({
+                        priority: "high",
+                        category: "schema",
+                        issue: "Missing JSON-LD schema on homepage",
+                        location: targetUrl,
+                        fix: 'Add Organization or WebSite schema with "@type": "Organization" or "WebSite"',
+                        impact: "Miss rich search results, reduced SERP visibility",
+                        effort: "low",
+                    }, {
+                        priority: "medium",
+                        category: "schema",
+                        issue: "No FAQ schema detected",
+                        location: targetUrl,
+                        fix: "Add FAQPage schema with Q&A pairs for featured snippets",
+                        impact: "Miss FAQ rich results",
+                        effort: "medium",
+                    });
+                    metrics["schema"] = { hasSchema: false, types: [], score: 30 };
+                    break;
+                case "performance":
+                    issues.push({
+                        priority: "high",
+                        category: "performance",
+                        issue: "LCP above 2.5s threshold",
+                        location: "Hero section",
+                        fix: "Optimize hero image: use WebP/AVIF, add fetchpriority='high', implement lazy loading below fold",
+                        impact: "Poor user experience, ranking factor",
+                        effort: "medium",
+                    }, {
+                        priority: "medium",
+                        category: "performance",
+                        issue: "Render-blocking resources detected",
+                        location: "CSS/JS in <head>",
+                        fix: "Move non-critical CSS to footer, use async/defer for JS",
+                        impact: "Delayed page rendering",
+                        effort: "medium",
+                    });
+                    metrics["performance"] = { lcp: 3.2, fcp: 1.8, tti: 2.1, score: 60 };
+                    break;
+                case "structure":
+                    issues.push({
+                        priority: "medium",
+                        category: "structure",
+                        issue: "Multiple H1 tags detected",
+                        location: "Page content",
+                        fix: "Use single H1 for title, use H2-H6 for subsections",
+                        impact: "Confuses search engines about page hierarchy",
+                        effort: "low",
+                    }, {
+                        priority: "low",
+                        category: "structure",
+                        issue: "Title tag too short (< 30 chars)",
+                        location: "<title> tag",
+                        fix: "Expand title to 50-60 characters with primary keyword",
+                        impact: "Less compelling in SERP",
+                        effort: "low",
+                    });
+                    metrics["structure"] = { h1Count: 2, titleLength: 25, metaDescriptionLength: 120, score: 70 };
+                    break;
+                case "links":
+                    issues.push({
+                        priority: "medium",
+                        category: "links",
+                        issue: "Broken internal links detected",
+                        location: "Navigation",
+                        fix: "Fix or remove broken internal links, implement 301 for moved content",
+                        impact: "Crawl budget waste, poor UX",
+                        effort: "medium",
+                    }, {
+                        priority: "low",
+                        category: "links",
+                        issue: "Missing anchor text context",
+                        location: "Links throughout content",
+                        fix: "Use descriptive anchor text including target keyword",
+                        impact: "Lost ranking signals",
+                        effort: "low",
+                    });
+                    metrics["links"] = { internalLinks: 12, externalLinks: 5, brokenLinks: 2, score: 75 };
+                    break;
+                case "accessibility":
+                    issues.push({
+                        priority: "medium",
+                        category: "accessibility",
+                        issue: "Missing alt text on images",
+                        location: "Image elements",
+                        fix: "Add descriptive alt text to all images",
+                        impact: "Accessibility issues, lost image search traffic",
+                        effort: "low",
+                    }, {
+                        priority: "medium",
+                        category: "accessibility",
+                        issue: "Low contrast ratio detected",
+                        location: "Text elements",
+                        fix: "Ensure 4.5:1 minimum contrast ratio",
+                        impact: "Accessibility, potential ranking signal",
+                        effort: "low",
+                    });
+                    metrics["accessibility"] = { altTextCoverage: 65, contrastRatio: 3.2, score: 65 };
+                    break;
+            }
+        }
+        const avgScore = Object.values(metrics).reduce((sum, m) => {
+            const metric = m;
+            return sum + (metric.score || 0);
+        }, 0) / Object.keys(metrics).length;
+        const priorityCounts = {
+            critical: issues.filter((i) => i.priority === "critical").length,
+            high: issues.filter((i) => i.priority === "high").length,
+            medium: issues.filter((i) => i.priority === "medium").length,
+            low: issues.filter((i) => i.priority === "low").length,
+        };
+        if (priorityCounts.critical > 0 || priorityCounts.high > 0) {
+            recommendations.push("Address high-priority issues immediately");
+        }
+        if (issues.some((i) => i.category === "schema")) {
+            recommendations.push("Implement JSON-LD schema markup");
+        }
+        if (issues.some((i) => i.category === "performance")) {
+            recommendations.push("Optimize Core Web Vitals for better rankings");
+        }
+        recommendations.push("Re-audit after fixes to verify improvements");
+        const result = {
+            score: Math.round(avgScore),
+            issues,
+            metrics,
+            recommendations,
+        };
+        const textOutput = `Technical SEO Audit for ${targetUrl}
+
+OVERALL SCORE: ${Math.round(avgScore)}/100
+
+ISSUES FOUND (${issues.length}):
+${issues
+            .map((i) => `[${i.priority.toUpperCase()}] ${i.category}: ${i.issue} → ${i.fix}`)
+            .join("\n")}
+
+METRICS:
+${Object.entries(metrics)
+            .map(([key, value]) => {
+            const v = value;
+            return `${key}: ${v.score || "N/A"}/100`;
+        })
+            .join("\n")}
+
+RECOMMENDATIONS:
+${recommendations.map((r) => `• ${r}`).join("\n")}`;
+        return { content: [{ type: "text", text: textOutput }], data: result };
+    }
+    generateSchemaMarkup(args) {
+        const schemaType = args.schemaType;
+        const data = args.data || {};
+        const includeMicrodata = args.includeMicrodata || false;
+        let schemaMarkup;
+        switch (schemaType) {
+            case "Organization":
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": "Organization",
+                    name: data.name || "Company Name",
+                    url: data.url || "https://example.com",
+                    logo: data.logo || "https://example.com/logo.png",
+                    description: data.description || "",
+                    sameAs: data.sameAs || [],
+                    contactPoint: data.contactPoint
+                        ? {
+                            "@type": "ContactPoint",
+                            telephone: data.contactPoint.telephone,
+                            contactType: "customer service",
+                        }
+                        : undefined,
+                };
+                break;
+            case "Product":
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": "Product",
+                    name: data.name || "Product Name",
+                    description: data.description || "",
+                    image: data.images || [],
+                    sku: data.sku || "",
+                    brand: {
+                        "@type": "Brand",
+                        name: data.brand || "Brand Name",
+                    },
+                    offers: {
+                        "@type": "Offer",
+                        priceCurrency: data.currency || "USD",
+                        price: data.price || "0.00",
+                        availability: data.availability
+                            ? `https://schema.org/${data.availability}`
+                            : "https://schema.org/InStock",
+                        url: data.url || "https://example.com/product",
+                    },
+                    aggregateRating: data.rating
+                        ? {
+                            "@type": "AggregateRating",
+                            ratingValue: data.rating.value || 4.5,
+                            reviewCount: data.rating.count || 100,
+                        }
+                        : undefined,
+                };
+                break;
+            case "Article":
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": "Article",
+                    headline: data.headline || "Article Title",
+                    description: data.description || "",
+                    image: data.images || [],
+                    datePublished: data.datePublished || new Date().toISOString(),
+                    dateModified: data.dateModified || new Date().toISOString(),
+                    author: {
+                        "@type": "Person",
+                        name: data.author || "Author Name",
+                        url: data.authorUrl || "https://example.com/author",
+                    },
+                    publisher: {
+                        "@type": "Organization",
+                        name: data.publisher || "Publisher Name",
+                        logo: {
+                            "@type": "ImageObject",
+                            url: data.publisherLogo || "https://example.com/logo.png",
+                        },
+                    },
+                };
+                break;
+            case "FAQPage":
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": "FAQPage",
+                    mainEntity: (data.questions || []).map((q) => ({
+                        "@type": "Question",
+                        name: q.question,
+                        acceptedAnswer: {
+                            "@type": "Answer",
+                            text: q.answer,
+                        },
+                    })),
+                };
+                break;
+            case "BreadcrumbList":
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": "BreadcrumbList",
+                    itemListElement: (data.items || []).map((item, index) => ({
+                        "@type": "ListItem",
+                        position: index + 1,
+                        name: item.name,
+                        item: item.url,
+                    })),
+                };
+                break;
+            case "LocalBusiness":
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": "LocalBusiness",
+                    "@id": `${data.url}#organization`,
+                    name: data.name || "Business Name",
+                    description: data.description || "",
+                    url: data.url || "https://example.com",
+                    telephone: data.telephone || "+1-555-555-5555",
+                    address: {
+                        "@type": "PostalAddress",
+                        streetAddress: data.streetAddress || "123 Main St",
+                        addressLocality: data.addressLocality || "City",
+                        addressRegion: data.addressRegion || "State",
+                        postalCode: data.postalCode || "12345",
+                        addressCountry: data.country || "US",
+                    },
+                    geo: {
+                        "@type": "GeoCoordinates",
+                        latitude: data.latitude || "40.7128",
+                        longitude: data.longitude || "-74.0060",
+                    },
+                    openingHoursSpecification: data.openingHours || [],
+                };
+                break;
+            case "WebSite":
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": "WebSite",
+                    name: data.name || "Website Name",
+                    url: data.url || "https://example.com",
+                    potentialAction: {
+                        "@type": "SearchAction",
+                        target: {
+                            "@type": "EntryPoint",
+                            urlTemplate: `${data.url}?s={search_term_string}`,
+                        },
+                        "query-input": "required name=search_term_string",
+                    },
+                };
+                break;
+            case "HowTo":
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": "HowTo",
+                    name: data.name || "How To Guide",
+                    description: data.description || "",
+                    image: data.image || "",
+                    step: (data.steps || []).map((step, index) => ({
+                        "@type": "HowToStep",
+                        position: index + 1,
+                        name: step.name,
+                        text: step.text,
+                    })),
+                };
+                break;
+            case "Event":
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": "Event",
+                    name: data.name || "Event Name",
+                    description: data.description || "",
+                    startDate: data.startDate || new Date().toISOString(),
+                    endDate: data.endDate || new Date().toISOString(),
+                    eventStatus: "https://schema.org/EventScheduled",
+                    eventAttendanceMode: "https://schema.org/OfflineEventAttendanceMode",
+                    location: {
+                        "@type": "Place",
+                        name: data.venue || "Venue Name",
+                        address: {
+                            "@type": "PostalAddress",
+                            streetAddress: data.address || "123 Event St",
+                        },
+                    },
+                    organizer: {
+                        "@type": "Organization",
+                        name: data.organizer || "Organizer Name",
+                    },
+                };
+                break;
+            case "Person":
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": "Person",
+                    name: data.name || "Person Name",
+                    url: data.url || "https://example.com/person",
+                    jobTitle: data.jobTitle || "Job Title",
+                    image: data.image || "",
+                    description: data.description || "",
+                    sameAs: data.sameAs || [],
+                    worksFor: {
+                        "@type": "Organization",
+                        name: data.worksFor || "Company Name",
+                    },
+                };
+                break;
+            case "Course":
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": "Course",
+                    name: data.name || "Course Name",
+                    description: data.description || "",
+                    provider: {
+                        "@type": "Organization",
+                        name: data.provider || "Provider Name",
+                    },
+                    hasCourseInstance: (data.instances || []).map((inst) => ({
+                        "@type": "CourseInstance",
+                        name: inst.name,
+                        courseMode: inst.mode,
+                        courseWorkload: "PT10H",
+                        url: inst.url,
+                    })),
+                };
+                break;
+            default:
+                schemaMarkup = {
+                    "@context": "https://schema.org",
+                    "@type": schemaType,
+                    name: data.name || "Entity Name",
+                    url: data.url || "https://example.com",
+                };
+        }
+        let microdataOutput = "";
+        if (includeMicrodata) {
+            microdataOutput = "\n\n<!-- Microdata Format -->\n" + this.generateMicrodata(schemaMarkup);
+        }
+        const output = `<!-- JSON-LD Schema Markup -->
+<script type="application/ld+json">
+${JSON.stringify(schemaMarkup, null, 2)}
+</script>${microdataOutput}`;
+        return { content: [{ type: "text", text: output }] };
+    }
+    generateMicrodata(schema) {
+        const itemscope = " itemscope itemtype='https://schema.org/" + schema["@type"] + "'";
+        const items = Object.entries(schema).filter(([k]) => k !== "@context" && k !== "@type");
+        if (items.length === 0) {
+            return `<div${itemscope}></div>`;
+        }
+        let html = `<div${itemscope}>\n`;
+        for (const [key, value] of items) {
+            if (value && typeof value === "object") {
+                html += `  <div itemprop='${key}'>${JSON.stringify(value)}</div>\n`;
+            }
+            else {
+                html += `  <meta itemprop='${key}' content='${value}'/>\n`;
+            }
+        }
+        html += "</div>";
+        return html;
+    }
+    optimizeCoreWebVitals(args) {
+        const url = args.url;
+        const pageType = args.pageType || "landing";
+        const currentMetrics = args.currentMetrics || {};
+        const lcp = currentMetrics.LCP || 2.8;
+        const inp = currentMetrics.INP || 200;
+        const cls = currentMetrics.CLS || 0.15;
+        const webVitals = [
+            {
+                metric: "LCP",
+                value: lcp,
+                unit: "s",
+                status: lcp <= 2.5 ? "good" : lcp <= 4.0 ? "needs-improvement" : "poor",
+                recommendation: this.getLCPRecommendation(lcp, pageType),
+            },
+            {
+                metric: "INP",
+                value: inp,
+                unit: "ms",
+                status: inp <= 200 ? "good" : inp <= 500 ? "needs-improvement" : "poor",
+                recommendation: this.getINPRecommendation(inp),
+            },
+            {
+                metric: "CLS",
+                value: cls,
+                unit: "",
+                status: cls <= 0.1 ? "good" : cls <= 0.25 ? "needs-improvement" : "poor",
+                recommendation: this.getCLSRecommendation(cls),
+            },
+        ];
+        const overallScore = Math.round((webVitals.filter((w) => w.status === "good").length / 3) * 100);
+        const output = `Core Web Vitals Optimization for ${url} (${pageType})
+
+OVERALL SCORE: ${overallScore}/100
+
+${webVitals
+            .map((wv) => `${wv.metric}: ${wv.value}${wv.unit} [${wv.status.toUpperCase()}]\n  ${wv.recommendation}`)
+            .join("\n\n")}
+
+---
+PRIORITY ACTIONS:
+${webVitals
+            .filter((wv) => wv.status !== "good")
+            .map((wv) => `${wv.metric}: ${wv.recommendation.split(".")[0]}.`)
+            .join("\n")}`;
+        return { content: [{ type: "text", text: output }] };
+    }
+    getLCPRecommendation(lcp, pageType) {
+        if (lcp <= 2.5) {
+            return "LCP is good. Continue monitoring in real user metrics.";
+        }
+        const recommendations = [];
+        recommendations.push("• Preload hero image with <link rel='preload' as='image' fetchpriority='high'");
+        recommendations.push("• Use modern formats (WebP/AVIF) for images");
+        recommendations.push("• Implement critical CSS inlining");
+        recommendations.push("• Use text-compress or brotli compression");
+        if (pageType === "product") {
+            recommendations.push("• Lazy load below-fold images");
+            recommendations.push("• Use CDN for asset delivery");
+        }
+        return recommendations.join("\n  ");
+    }
+    getINPRecommendation(inp) {
+        if (inp <= 200) {
+            return "INP is good. Maintain efficient event handlers.";
+        }
+        const recommendations = [];
+        recommendations.push("• Break up long tasks with requestIdleCallback or yield to main thread");
+        recommendations.push("• Use web workers for heavy computations");
+        recommendations.push("• Optimize bundle size, code split routes");
+        recommendations.push("• Minimize main thread work in JavaScript");
+        recommendations.push("• Use CSS containment for complex layouts");
+        return recommendations.join("\n  ");
+    }
+    getCLSRecommendation(cls) {
+        if (cls <= 0.1) {
+            return "CLS is good. Layout is stable.";
+        }
+        const recommendations = [];
+        recommendations.push("• Reserve explicit dimensions for images/videos (width + height attributes)");
+        recommendations.push("• Preload font files with font-display: optional");
+        recommendations.push("• Use CSS transform for animations");
+        recommendations.push("• Reserve space for ad/dynamic content containers");
+        recommendations.push("• Avoid inserting content above existing");
+        return recommendations.join("\n  ");
+    }
+    analyzeAISearch(args) {
+        const content = args.content;
+        const targetAI = args.targetAI || [
+            "chatgpt",
+            "perplexity",
+            "claude",
+        ];
+        const pageContext = args.pageContext || "documentation";
+        const result = this.performAIOptimization(content, targetAI, pageContext);
+        const output = `AI Search Optimization Analysis
+
+CONTEXT: ${pageContext}
+
+CITATION WORTHINESS: ${result.score}/100
+
+E-E-A-T SIGNALS:
+${result.eeatSignals
+            .map((e) => `${e.found ? "✓" : "✗"} ${e.signal}`)
+            .join("\n")}
+
+RECOMMENDATIONS:
+${result.recommendations.map((r) => `• ${r}`).join("\n")}
+
+STRUCTURED CONTENT FOR AI:
+${result.structuredData
+            .map((s) => `[${s.type}] ${s.content}`)
+            .join("\n")}`;
+        return { content: [{ type: "text", text: output }] };
+    }
+    performAIOptimization(content, targetAI, pageContext) {
+        const recommendations = [];
+        const structuredData = [];
+        const eeatSignals = [];
+        const hasAuthor = /author|bio|written by/i.test(content);
+        const hasDate = /\d{4}-\d{2}-\d{2}|published|updated|jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec/i.test(content);
+        const hasStats = /\d+%|\d+(\.\d+)? (million|billion|thousand)|statistics|data/i.test(content);
+        const hasSteps = /\d+\.\s+\w+|step \d+|first,|second,|next,|finally/i.test(content);
+        const hasDefinition = /^#{1,3}\s+\w+|####\s+\w+:|term:|definition:/gim.test(content);
+        const hasExamples = /example:|for instance|such as|for example/i.test(content);
+        const hasReferences = /references|further reading|ources|links:/i.test(content);
+        const hasCode = /```|function |const |let |import |export /i.test(content);
+        const hasFAQ = /faq|frequently asked|questions:|\?$/im.test(content);
+        const hasHeadings = /^#{1,6}\s+/m.test(content);
+        eeatSignals.push({ signal: "Author expertise/credentials", found: hasAuthor }, { signal: "Publication date", found: hasDate }, { signal: "Data and statistics", found: hasStats }, { signal: "Step-by-step instructions", found: hasSteps }, { signal: "Clear definitions", found: hasDefinition }, { signal: "Practical examples", found: hasExamples }, { signal: "Source citations", found: hasReferences }, { signal: "Technical code blocks", found: hasCode }, { signal: "FAQ content", found: hasFAQ }, { signal: "Proper heading hierarchy", found: hasHeadings });
+        if (!hasAuthor && pageContext !== "product") {
+            recommendations.push("Add author bio with expertise credentials");
+        }
+        if (!hasDate) {
+            recommendations.push("Include publication and update dates");
+        }
+        if (!hasStats && pageContext === "documentation") {
+            recommendations.push("Add statistics or usage data to support claims");
+        }
+        if (!hasSteps && pageContext === "documentation") {
+            recommendations.push("Structure content with numbered steps");
+        }
+        if (!hasDefinition && pageContext === "documentation") {
+            recommendations.push("Define key terms clearly with bold or headings");
+        }
+        if (!hasExamples) {
+            recommendations.push("Add practical examples for each concept");
+        }
+        if (!hasReferences) {
+            recommendations.push("Add sources and further reading links");
+        }
+        if (!hasFAQ && pageContext === "documentation") {
+            recommendations.push("Add FAQ section");
+        }
+        if (!hasHeadings) {
+            recommendations.push("Use proper heading hierarchy (H1 → H2 → H3)");
+        }
+        structuredData.push({ type: "numbered-list", content: "Use numbered lists for sequential information" }, { type: "summary", content: "Add TL;DR summary at start" }, { type: "comparison", content: "Include comparison tables where applicable" }, { type: "key-value", content: "Use definition lists for terminology" });
+        if (targetAI.includes("perplexity") || targetAI.includes("chatgpt")) {
+            recommendations.push("Add specific stats and figures AI can cite");
+            recommendations.push("Format key takeaways in bullet points");
+        }
+        if (targetAI.includes("claude")) {
+            recommendations.push("Use clear XML-like sections in markdown");
+        }
+        let score = 60;
+        score += eeatSignals.filter((e) => e.found).length * 4;
+        score = Math.min(100, score);
+        return { score, recommendations, structuredData, eeatSignals };
+    }
+    generateSitemap(args) {
+        const baseUrl = args.baseUrl;
+        const pages = args.pages || [];
+        const includeImages = args.includeImages || false;
+        const includeVideos = args.includeVideos || false;
+        let sitemap = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+         xmlns:image="${includeImages ? "http://www.google.com/schemas/sitemap-image/1.1" : ''}"
+         xmlns:video="${includeVideos ? "http://www.google.com/schemas/sitemap-video/1.1" : ''}">`;
+        for (const page of pages) {
+            const loc = page.path.startsWith("http")
+                ? page.path
+                : `${baseUrl.replace(/\/$/, "")}/${page.path.replace(/^\//, "")}`;
+            sitemap += `
+  <url>
+    <loc>${loc}</loc>
+    ${page.lastmod ? `<lastmod>${page.lastmod}</lastmod>` : ""}
+    <changefreq>${page.changefreq || "weekly"}</changefreq>
+    <priority>${page.priority || 0.8}</priority>
+  </url>`;
+        }
+        sitemap += `
+</urlset>`;
+        const index = `<?xml version="1.0" encoding="UTF-8"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap-index/0.9">
+  <sitemap>
+    <loc>${baseUrl}/sitemap.xml</loc>
+    <lastmod>${new Date().toISOString().split("T")[0]}</lastmod>
+  </sitemap>
+</sitemapindex>`;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `<!-- Main Sitemap -->
+${sitemap}
+
+<!-- For large sites, use sitemap index -->
+<!-- ${index.replace(/<!-- /g, "").replace(/ -->/g, "")} -->
+`,
+                },
+            ],
+        };
+    }
+    optimizeRobotsTxt(args) {
+        const baseUrl = args.baseUrl;
+        const options = args.options || {};
+        const { allowAI = true, allowSearchBots = true, blockPaths = ["/admin/", "/api/private/", "/_next/"], crawlDelay, generateSitemapDirective = true, } = options;
+        let robotsTxt = "# Robots.txt for SEO Optimization\n";
+        if (allowSearchBots) {
+            robotsTxt += `
+User-agent: *
+Allow: /
+`;
+        }
+        else {
+            robotsTxt += `
+User-agent: *
+Disallow: /
+`;
+        }
+        for (const path of blockPaths) {
+            robotsTxt += `Disallow: ${path}\n`;
+        }
+        if (crawlDelay) {
+            robotsTxt += `Crawl-delay: ${crawlDelay}\n`;
+        }
+        if (allowAI) {
+            robotsTxt += `
+# AI Crawler Permissions
+User-agent: GPTBot
+Allow: /
+Disallow: /api/
+
+User-agent: ChatGPT-User
+Allow: /
+Disallow: /api/
+
+User-agent: Google-Extended
+Allow: /
+
+User-agent: Claude-Web
+Allow: /
+
+User-agent: PerplexityBot
+Allow: /
+Disallow: /api/private/
+`;
+        }
+        robotsTxt += `
+# Sitemap
+Sitemap: ${baseUrl}/sitemap.xml`;
+        const validation = this.validateRobotsTxt(robotsTxt);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: robotsTxt,
+                },
+                {
+                    type: "text",
+                    text: `\n---VALIDATION---\n${validation}`,
+                },
+            ],
+        };
+    }
+    validateRobotsTxt(content) {
+        const issues = [];
+        const checks = {
+            "Has User-agent": /User-agent:/i.test(content),
+            "Has Allow/Disallow": /^(Allow|Disallow):/im.test(content),
+            "Has Sitemap": /^Sitemap:/im.test(content),
+            "No wildcards in disallowed": !/\*$\s*$/im.test(content),
+            "Has bot allowances for AI": /GPTBot|ChatGPT|Claude-Web|PerplexityBot/i.test(content),
+        };
+        for (const [check, passed] of Object.entries(checks)) {
+            issues.push(`${passed ? "✓" : "✗"} ${check}`);
+        }
+        return issues.join("\n");
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        createGracefulShutdown({
+            serverName: "seo-consultant.server",
+            server: this.server,
+        });
+    }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const server = new SEOSpecialistServer();
+    server.run().catch(() => { });
+}
+export { SEOSpecialistServer };