mcp-wordpress 2.6.4 → 2.7.0

package/dist/tools/seo/generators/SchemaGenerator.js

@@ -0,0 +1,670 @@
+/**
+ * Schema Generator
+ *
+ * This module generates JSON-LD structured data markup for WordPress content.
+ * It supports all major Schema.org types and provides intelligent content extraction
+ * and schema optimization for better search engine understanding.
+ *
+ * Supported Schema Types:
+ * - Article, BlogPosting, NewsArticle
+ * - Product, Offer, AggregateRating
+ * - FAQ, Question, Answer
+ * - HowTo, HowToStep, HowToDirection
+ * - Organization, LocalBusiness, Person
+ * - Website, WebPage, BreadcrumbList
+ * - Event, Recipe, Course, VideoObject
+ *
+ * @since 2.7.0
+ */
+import { LoggerFactory } from "../../../utils/logger.js";
+/**
+ * Schema Generator Class
+ */
+export class SchemaGenerator {
+    logger = LoggerFactory.tool("schema_generator");
+    constructor() { }
+    /**
+     * Generate schema markup for a WordPress post
+     */
+    async generateSchema(post, params, options = {}) {
+        this.logger.debug("Generating schema markup", {
+            postId: post.id,
+            schemaType: params.schemaType,
+            title: post.title?.rendered?.substring(0, 50),
+        });
+        if (!params.schemaType) {
+            throw new Error("Schema type is required for schema generation");
+        }
+        const baseSchema = {
+            "@context": "https://schema.org",
+            "@type": params.schemaType,
+        };
+        // Generate schema based on type
+        switch (params.schemaType) {
+            case "Article":
+                return this.generateArticleSchema(post, baseSchema, options);
+            case "Product":
+                return this.generateProductSchema(post, baseSchema, options);
+            case "FAQ":
+                return this.generateFAQSchema(post, baseSchema, options);
+            case "HowTo":
+                return this.generateHowToSchema(post, baseSchema, options);
+            case "Organization":
+                return this.generateOrganizationSchema(post, baseSchema, options);
+            case "LocalBusiness":
+                return this.generateLocalBusinessSchema(post, baseSchema, options);
+            case "Website":
+                return this.generateWebsiteSchema(post, baseSchema, options);
+            case "BreadcrumbList":
+                return this.generateBreadcrumbSchema(post, baseSchema, options);
+            case "Event":
+                return this.generateEventSchema(post, baseSchema, options);
+            case "Recipe":
+                return this.generateRecipeSchema(post, baseSchema, options);
+            case "Course":
+                return this.generateCourseSchema(post, baseSchema, options);
+            case "VideoObject":
+                return this.generateVideoSchema(post, baseSchema, options);
+            case "Person":
+                return this.generatePersonSchema(post, baseSchema, options);
+            case "Review":
+                return this.generateReviewSchema(post, baseSchema, options);
+            default:
+                throw new Error(`Unsupported schema type: ${params.schemaType}`);
+        }
+    }
+    /**
+     * Generate Article schema markup
+     */
+    generateArticleSchema(post, baseSchema, options) {
+        const content = this.extractTextContent(post.content?.rendered || "");
+        const excerpt = this.extractTextContent(post.excerpt?.rendered || "");
+        const images = this.extractImages(post.content?.rendered || "");
+        const articleData = {
+            headline: post.title?.rendered || "Untitled",
+            description: excerpt || content.substring(0, 160) + "...",
+            datePublished: post.date || new Date().toISOString(),
+            dateModified: post.modified || post.date || new Date().toISOString(),
+            author: {
+                "@type": "Person",
+                name: this.getAuthorName(post),
+                ...(this.getAuthorUrl(post) ? { url: this.getAuthorUrl(post) } : {}),
+            },
+            publisher: this.getPublisherInfo(options),
+            mainEntityOfPage: post.link || `https://example.com/post/${post.id}`,
+            wordCount: this.countWords(content),
+            ...(images.length > 0 && { image: images }),
+            ...(options.customProperties?.keywords ? { keywords: options.customProperties.keywords } : {}),
+        };
+        return {
+            ...baseSchema,
+            ...articleData,
+        };
+    }
+    /**
+     * Generate Product schema markup
+     */
+    generateProductSchema(post, baseSchema, options) {
+        const content = this.extractTextContent(post.content?.rendered || "");
+        const excerpt = this.extractTextContent(post.excerpt?.rendered || "");
+        const images = this.extractImages(post.content?.rendered || "");
+        // Extract product information from content
+        const productInfo = this.extractProductInfo(content);
+        const productData = {
+            name: post.title?.rendered || "Untitled Product",
+            description: excerpt || content.substring(0, 160) + "...",
+            ...(images.length > 0 && { image: images }),
+            ...(productInfo.brand && {
+                brand: {
+                    "@type": "Brand",
+                    name: productInfo.brand,
+                },
+            }),
+            ...(productInfo.price && {
+                offers: {
+                    "@type": "Offer",
+                    price: productInfo.price,
+                    priceCurrency: productInfo.currency || "USD",
+                    availability: productInfo.availability || "https://schema.org/InStock",
+                    url: post.link || `https://example.com/product/${post.id}`,
+                    ...(productInfo.validFrom && { validFrom: productInfo.validFrom }),
+                    ...(productInfo.validThrough && { validThrough: productInfo.validThrough }),
+                },
+            }),
+            ...(productInfo.rating && {
+                aggregateRating: {
+                    "@type": "AggregateRating",
+                    ratingValue: productInfo.rating.average,
+                    reviewCount: productInfo.rating.count,
+                    bestRating: productInfo.rating.best || 5,
+                    worstRating: productInfo.rating.worst || 1,
+                },
+            }),
+        };
+        return {
+            ...baseSchema,
+            ...productData,
+        };
+    }
+    /**
+     * Generate FAQ schema markup
+     */
+    generateFAQSchema(post, baseSchema, options) {
+        const content = post.content?.rendered || "";
+        const faqItems = this.extractFAQItems(content);
+        if (faqItems.length === 0) {
+            this.logger.warn("No FAQ items found in content", { postId: post.id });
+        }
+        const faqData = {
+            mainEntity: faqItems.map((item) => ({
+                "@type": "Question",
+                name: item.question,
+                acceptedAnswer: {
+                    "@type": "Answer",
+                    text: item.answer,
+                },
+            })),
+        };
+        return {
+            ...baseSchema,
+            ...faqData,
+        };
+    }
+    /**
+     * Generate HowTo schema markup
+     */
+    generateHowToSchema(post, baseSchema, options) {
+        const content = post.content?.rendered || "";
+        const steps = this.extractHowToSteps(content);
+        const images = this.extractImages(content);
+        const totalTime = this.extractDuration(content);
+        return {
+            ...baseSchema,
+            name: post.title?.rendered || "Untitled Guide",
+            description: this.extractTextContent(post.excerpt?.rendered || "").substring(0, 160),
+            ...(images.length > 0 && { image: images }),
+            ...(totalTime && { totalTime }),
+            supply: this.extractSupplies(content),
+            tool: this.extractTools(content),
+            step: steps.map((step, index) => ({
+                "@type": "HowToStep",
+                position: index + 1,
+                name: step.name,
+                text: step.text,
+                ...(step.image && { image: step.image }),
+            })),
+        };
+    }
+    /**
+     * Generate Organization schema markup
+     */
+    generateOrganizationSchema(post, baseSchema, options) {
+        const siteConfig = options.siteConfig || {};
+        return {
+            ...baseSchema,
+            name: siteConfig.name || post.title?.rendered || "Organization",
+            description: siteConfig.description || this.extractTextContent(post.excerpt?.rendered || ""),
+            url: siteConfig.url || post.link || "https://example.com",
+            ...(siteConfig.logo && {
+                logo: {
+                    "@type": "ImageObject",
+                    url: siteConfig.logo,
+                },
+            }),
+            ...(siteConfig.socialProfiles && { sameAs: siteConfig.socialProfiles }),
+            ...(siteConfig.contactInfo && {
+                contactPoint: {
+                    "@type": "ContactPoint",
+                    ...(siteConfig.contactInfo.telephone && { telephone: siteConfig.contactInfo.telephone }),
+                    ...(siteConfig.contactInfo.email && { email: siteConfig.contactInfo.email }),
+                },
+            }),
+        };
+    }
+    /**
+     * Generate LocalBusiness schema markup
+     */
+    generateLocalBusinessSchema(post, baseSchema, options) {
+        const organizationSchema = this.generateOrganizationSchema(post, baseSchema, options);
+        const businessInfo = this.extractBusinessInfo(post.content?.rendered || "");
+        return {
+            ...organizationSchema,
+            "@type": "LocalBusiness",
+            ...(businessInfo.address && {
+                address: {
+                    "@type": "PostalAddress",
+                    streetAddress: businessInfo.address.street,
+                    addressLocality: businessInfo.address.city,
+                    addressRegion: businessInfo.address.state,
+                    postalCode: businessInfo.address.zip,
+                    addressCountry: businessInfo.address.country,
+                },
+            }),
+            ...(businessInfo.phone && { telephone: businessInfo.phone }),
+            ...(businessInfo.hours && { openingHours: businessInfo.hours }),
+            ...(businessInfo.priceRange && { priceRange: businessInfo.priceRange }),
+        };
+    }
+    /**
+     * Generate Website schema markup
+     */
+    generateWebsiteSchema(post, baseSchema, options) {
+        const siteConfig = options.siteConfig || {};
+        return {
+            ...baseSchema,
+            name: siteConfig.name || "Website",
+            description: siteConfig.description || this.extractTextContent(post.excerpt?.rendered || ""),
+            url: siteConfig.url || "https://example.com",
+            ...(options.includeAuthor && {
+                author: {
+                    "@type": "Organization",
+                    name: siteConfig.name || "Website Owner",
+                },
+            }),
+            potentialAction: {
+                "@type": "SearchAction",
+                target: {
+                    "@type": "EntryPoint",
+                    urlTemplate: `${siteConfig.url || "https://example.com"}?s={search_term_string}`,
+                },
+                "query-input": "required name=search_term_string",
+            },
+        };
+    }
+    /**
+     * Generate BreadcrumbList schema markup
+     */
+    generateBreadcrumbSchema(post, baseSchema, options) {
+        // Extract breadcrumb path from post URL or categories
+        const breadcrumbs = this.extractBreadcrumbs(post);
+        return {
+            ...baseSchema,
+            itemListElement: breadcrumbs.map((breadcrumb, index) => ({
+                "@type": "ListItem",
+                position: index + 1,
+                name: breadcrumb.name,
+                item: breadcrumb.url,
+            })),
+        };
+    }
+    /**
+     * Generate Event schema markup
+     */
+    generateEventSchema(post, baseSchema, options) {
+        const eventInfo = this.extractEventInfo(post.content?.rendered || "");
+        return {
+            ...baseSchema,
+            name: post.title?.rendered || "Event",
+            description: this.extractTextContent(post.excerpt?.rendered || ""),
+            startDate: eventInfo.startDate || new Date().toISOString(),
+            ...(eventInfo.endDate && { endDate: eventInfo.endDate }),
+            ...(eventInfo.location && {
+                location: {
+                    "@type": "Place",
+                    name: eventInfo.location.name,
+                    ...(eventInfo.location.address && {
+                        address: {
+                            "@type": "PostalAddress",
+                            streetAddress: eventInfo.location.address,
+                        },
+                    }),
+                },
+            }),
+            ...(eventInfo.organizer && {
+                organizer: {
+                    "@type": "Organization",
+                    name: eventInfo.organizer,
+                },
+            }),
+        };
+    }
+    /**
+     * Generate Recipe schema markup
+     */
+    generateRecipeSchema(post, baseSchema, options) {
+        const recipeInfo = this.extractRecipeInfo(post.content?.rendered || "");
+        const images = this.extractImages(post.content?.rendered || "");
+        return {
+            ...baseSchema,
+            name: post.title?.rendered || "Recipe",
+            description: this.extractTextContent(post.excerpt?.rendered || ""),
+            ...(images.length > 0 && { image: images }),
+            author: {
+                "@type": "Person",
+                name: this.getAuthorName(post),
+            },
+            ...(recipeInfo.prepTime && { prepTime: recipeInfo.prepTime }),
+            ...(recipeInfo.cookTime && { cookTime: recipeInfo.cookTime }),
+            ...(recipeInfo.totalTime && { totalTime: recipeInfo.totalTime }),
+            ...(recipeInfo.servings && { recipeYield: recipeInfo.servings }),
+            ...(recipeInfo.ingredients.length > 0 && { recipeIngredient: recipeInfo.ingredients }),
+            ...(recipeInfo.instructions.length > 0 && {
+                recipeInstructions: recipeInfo.instructions.map((instruction, index) => ({
+                    "@type": "HowToStep",
+                    position: index + 1,
+                    text: instruction,
+                })),
+            }),
+            ...(recipeInfo.nutrition && {
+                nutrition: {
+                    "@type": "NutritionInformation",
+                    calories: recipeInfo.nutrition.calories,
+                },
+            }),
+        };
+    }
+    /**
+     * Generate Course schema markup
+     */
+    generateCourseSchema(post, baseSchema, options) {
+        const courseInfo = this.extractCourseInfo(post.content?.rendered || "");
+        return {
+            ...baseSchema,
+            name: post.title?.rendered || "Course",
+            description: this.extractTextContent(post.excerpt?.rendered || ""),
+            provider: {
+                "@type": "Organization",
+                name: options.siteConfig?.name || "Course Provider",
+            },
+            ...(courseInfo.instructor && {
+                instructor: {
+                    "@type": "Person",
+                    name: courseInfo.instructor,
+                },
+            }),
+            ...(courseInfo.duration && { timeRequired: courseInfo.duration }),
+            ...(courseInfo.level && { courseLevel: courseInfo.level }),
+            ...(courseInfo.prerequisites.length > 0 && { coursePrerequisites: courseInfo.prerequisites }),
+        };
+    }
+    /**
+     * Generate VideoObject schema markup
+     */
+    generateVideoSchema(post, baseSchema, options) {
+        const videoInfo = this.extractVideoInfo(post.content?.rendered || "");
+        return {
+            ...baseSchema,
+            name: post.title?.rendered || "Video",
+            description: this.extractTextContent(post.excerpt?.rendered || ""),
+            ...(videoInfo.url && { contentUrl: videoInfo.url }),
+            ...(videoInfo.thumbnail && { thumbnailUrl: videoInfo.thumbnail }),
+            ...(videoInfo.duration && { duration: videoInfo.duration }),
+            uploadDate: post.date || new Date().toISOString(),
+            author: {
+                "@type": "Person",
+                name: this.getAuthorName(post),
+            },
+        };
+    }
+    /**
+     * Generate Person schema markup
+     */
+    generatePersonSchema(post, baseSchema, options) {
+        const personInfo = this.extractPersonInfo(post.content?.rendered || "");
+        return {
+            ...baseSchema,
+            name: post.title?.rendered || "Person",
+            description: this.extractTextContent(post.excerpt?.rendered || ""),
+            ...(personInfo.jobTitle && { jobTitle: personInfo.jobTitle }),
+            ...(personInfo.affiliation && {
+                affiliation: {
+                    "@type": "Organization",
+                    name: personInfo.affiliation,
+                },
+            }),
+            ...(personInfo.email && { email: personInfo.email }),
+            ...(personInfo.socialProfiles && { sameAs: personInfo.socialProfiles }),
+        };
+    }
+    /**
+     * Generate Review schema markup
+     */
+    generateReviewSchema(post, baseSchema, options) {
+        const reviewInfo = this.extractReviewInfo(post.content?.rendered || "");
+        return {
+            ...baseSchema,
+            itemReviewed: {
+                "@type": reviewInfo.itemType || "Thing",
+                name: reviewInfo.itemName || "Reviewed Item",
+            },
+            reviewRating: {
+                "@type": "Rating",
+                ratingValue: reviewInfo.rating || 5,
+                bestRating: reviewInfo.bestRating || 5,
+                worstRating: reviewInfo.worstRating || 1,
+            },
+            author: {
+                "@type": "Person",
+                name: this.getAuthorName(post),
+            },
+            reviewBody: this.extractTextContent(post.content?.rendered || ""),
+            datePublished: post.date || new Date().toISOString(),
+        };
+    }
+    // Helper methods for content extraction
+    /**
+     * Extract plain text from HTML content
+     */
+    extractTextContent(html) {
+        return html
+            .replace(/<[^>]*>/g, " ")
+            .replace(/\s+/g, " ")
+            .trim();
+    }
+    /**
+     * Extract images from HTML content
+     */
+    extractImages(html) {
+        const images = [];
+        const imgRegex = /<img[^>]+src="([^"]+)"/gi;
+        let match;
+        while ((match = imgRegex.exec(html)) !== null) {
+            images.push(match[1]);
+        }
+        return images;
+    }
+    /**
+     * Count words in text
+     */
+    countWords(text) {
+        return text.split(/\s+/).filter((word) => word.length > 0).length;
+    }
+    /**
+     * Get author name from post
+     */
+    getAuthorName(post) {
+        // This would typically come from WordPress API author data
+        return "Author"; // Placeholder
+    }
+    /**
+     * Get author URL from post
+     */
+    getAuthorUrl(post) {
+        // This would typically come from WordPress API author data
+        return undefined; // Placeholder
+    }
+    /**
+     * Get publisher information
+     */
+    getPublisherInfo(options) {
+        const siteConfig = options.siteConfig || {};
+        return {
+            "@type": "Organization",
+            name: siteConfig.name || "Publisher",
+            ...(siteConfig.logo && {
+                logo: {
+                    "@type": "ImageObject",
+                    url: siteConfig.logo,
+                },
+            }),
+        };
+    }
+    /**
+     * Extract product information from content
+     */
+    extractProductInfo(content) {
+        // Implement product information extraction logic
+        return {}; // Placeholder
+    }
+    /**
+     * Extract FAQ items from content
+     */
+    extractFAQItems(html) {
+        const faqItems = [];
+        // Look for FAQ patterns in HTML
+        const faqRegex = /<h[23][^>]*>(.*?)<\/h[23]>\s*<p[^>]*>(.*?)<\/p>/gi;
+        let match;
+        while ((match = faqRegex.exec(html)) !== null) {
+            const question = this.extractTextContent(match[1]);
+            const answer = this.extractTextContent(match[2]);
+            if (question && answer) {
+                faqItems.push({ question, answer });
+            }
+        }
+        return faqItems;
+    }
+    /**
+     * Extract HowTo steps from content
+     */
+    extractHowToSteps(html) {
+        const steps = [];
+        // Look for step patterns in HTML
+        const stepRegex = /<h[23][^>]*>(.*?)<\/h[23]>\s*<p[^>]*>(.*?)<\/p>/gi;
+        let match;
+        while ((match = stepRegex.exec(html)) !== null) {
+            const name = this.extractTextContent(match[1]);
+            const text = this.extractTextContent(match[2]);
+            if (name && text) {
+                steps.push({ name, text });
+            }
+        }
+        return steps;
+    }
+    /**
+     * Extract duration from content
+     */
+    extractDuration(content) {
+        const durationMatch = content.match(/(\d+)\s*(minutes?|hours?|mins?)/i);
+        if (durationMatch) {
+            const value = parseInt(durationMatch[1]);
+            const unit = durationMatch[2].toLowerCase();
+            if (unit.startsWith("min")) {
+                return `PT${value}M`;
+            }
+            else if (unit.startsWith("hour")) {
+                return `PT${value}H`;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Extract supplies from content
+     */
+    extractSupplies(content) {
+        // Implement supplies extraction logic
+        return []; // Placeholder
+    }
+    /**
+     * Extract tools from content
+     */
+    extractTools(content) {
+        // Implement tools extraction logic
+        return []; // Placeholder
+    }
+    /**
+     * Extract business information from content
+     */
+    extractBusinessInfo(content) {
+        // Implement business info extraction logic
+        return {}; // Placeholder
+    }
+    /**
+     * Extract breadcrumbs from post
+     */
+    extractBreadcrumbs(post) {
+        // Implement breadcrumb extraction logic
+        return [
+            { name: "Home", url: "https://example.com" },
+            { name: post.title?.rendered || "Post", url: post.link || "#" },
+        ]; // Placeholder
+    }
+    /**
+     * Extract event information from content
+     */
+    extractEventInfo(content) {
+        // Implement event info extraction logic
+        return {}; // Placeholder
+    }
+    /**
+     * Extract recipe information from content
+     */
+    extractRecipeInfo(content) {
+        // Implement recipe info extraction logic
+        return {
+            ingredients: [],
+            instructions: [],
+        }; // Placeholder
+    }
+    /**
+     * Extract course information from content
+     */
+    extractCourseInfo(content) {
+        // Implement course info extraction logic
+        return {
+            prerequisites: [],
+        }; // Placeholder
+    }
+    /**
+     * Extract video information from content
+     */
+    extractVideoInfo(content) {
+        // Implement video info extraction logic
+        return {}; // Placeholder
+    }
+    /**
+     * Extract person information from content
+     */
+    extractPersonInfo(content) {
+        // Implement person info extraction logic
+        return {}; // Placeholder
+    }
+    /**
+     * Extract review information from content
+     */
+    extractReviewInfo(content) {
+        // Look for rating patterns in content
+        const ratingMatch = content.match(/(\d+(?:\.\d+)?)\s*(?:out of|\/)\s*(\d+)/i);
+        if (ratingMatch) {
+            return {
+                rating: parseFloat(ratingMatch[1]),
+                bestRating: parseInt(ratingMatch[2]),
+            };
+        }
+        return {}; // Placeholder
+    }
+    /**
+     * Validate generated schema markup
+     */
+    validateSchema(schema) {
+        const errors = [];
+        // Basic validation
+        if (!schema["@context"]) {
+            errors.push("Missing @context");
+        }
+        if (!schema["@type"]) {
+            errors.push("Missing @type");
+        }
+        // Type-specific validation
+        if (schema["@type"] === "Article" && !schema.headline) {
+            errors.push("Article schema missing required headline property");
+        }
+        if (schema["@type"] === "Product" && !schema.name) {
+            errors.push("Product schema missing required name property");
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+}
+//# sourceMappingURL=SchemaGenerator.js.map