0xray 4.0.11 → 4.0.13

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

@@ -1,745 +0,0 @@
-/**
- * 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 * as fs from "fs";
-import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
-class SEOSpecialistServer extends XrayKnowledgeSkillBase {
-    constructor() {
-        super("seo-consultant", "3.1.0");
-        this.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.handlers = {
-            "audit-technical-seo": async (args) => this.auditTechnicalSEO(args),
-            "generate-schema-markup": async (args) => this.generateSchemaMarkup(args),
-            "optimize-core-web-vitals": async (args) => this.optimizeCoreWebVitals(args),
-            "analyze-ai-search": async (args) => this.analyzeAISearch(args),
-            "generate-sitemap": async (args) => this.generateSitemap(args),
-            "optimize-robots-txt": async (args) => this.optimizeRobotsTxt(args),
-        };
-        this.setupToolHandlers();
-    }
-    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
-    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");
-    }
-}
-if (import.meta.url === `file://${fs.realpathSync(process.argv[1])}`) {
-    const server = new SEOSpecialistServer();
-    server.run().catch(() => { });
-}
-export { SEOSpecialistServer };