0xray 2.1.2 → 2.1.4

package/dist/mcps/knowledge-skills/content-creator.server.js

@@ -4,253 +4,232 @@
  * Content-focused SEO for both human readers and AI search engines.
  * Provides keyword optimization, meta descriptions, headlines, and conversion copy.
  */
-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 * as path from "path";
 import { fileURLToPath } from "url";
-class SEOCopywriterServer {
-    server;
-    tools = [
-        {
-            name: "seo_content_generation",
-            description: "Generate SEO-optimized content for blogs, product pages, landing pages",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    topic: { type: "string", description: "Main topic/keyword" },
-                    contentType: {
-                        type: "string",
-                        enum: ["blog", "product", "landing", "email", "social"],
-                    },
-                    wordCount: { type: "number", description: "Target word count" },
-                    targetAudience: {
-                        type: "string",
-                        description: "Target audience description",
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+class SEOCopywriterServer extends XrayKnowledgeSkillBase {
+    constructor() {
+        super("content-creator", "2.0.1");
+        this.tools = [
+            {
+                name: "seo_content_generation",
+                description: "Generate SEO-optimized content for blogs, product pages, landing pages",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        topic: { type: "string", description: "Main topic/keyword" },
+                        contentType: {
+                            type: "string",
+                            enum: ["blog", "product", "landing", "email", "social"],
+                        },
+                        wordCount: { type: "number", description: "Target word count" },
+                        targetAudience: {
+                            type: "string",
+                            description: "Target audience description",
+                        },
                     },
+                    required: ["topic", "contentType"],
                 },
-                required: ["topic", "contentType"],
             },
-        },
-        {
-            name: "keyword_optimization",
-            description: "Optimize existing content with relevant keywords and semantic variations",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    content: { type: "string", description: "Content to optimize" },
-                    primaryKeyword: {
-                        type: "string",
-                        description: "Primary keyword to target",
+            {
+                name: "keyword_optimization",
+                description: "Optimize existing content with relevant keywords and semantic variations",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        content: { type: "string", description: "Content to optimize" },
+                        primaryKeyword: {
+                            type: "string",
+                            description: "Primary keyword to target",
+                        },
                     },
+                    required: ["content", "primaryKeyword"],
                 },
-                required: ["content", "primaryKeyword"],
             },
-        },
-        {
-            name: "meta_description_generator",
-            description: "Generate compelling meta descriptions that improve CTR",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    pageTitle: { type: "string", description: "Page title" },
-                    pageContent: { type: "string", description: "Page content summary" },
-                    targetKeyword: { type: "string", description: "Primary keyword" },
+            {
+                name: "meta_description_generator",
+                description: "Generate compelling meta descriptions that improve CTR",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        pageTitle: { type: "string", description: "Page title" },
+                        pageContent: { type: "string", description: "Page content summary" },
+                        targetKeyword: { type: "string", description: "Primary keyword" },
+                    },
+                    required: ["pageTitle", "pageContent"],
                 },
-                required: ["pageTitle", "pageContent"],
             },
-        },
-        {
-            name: "headline_analyzer",
-            description: "Analyze and optimize headlines for SEO and conversion",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    headline: { type: "string", description: "Headline to analyze" },
-                    context: { type: "string", description: "Content context" },
+            {
+                name: "headline_analyzer",
+                description: "Analyze and optimize headlines for SEO and conversion",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        headline: { type: "string", description: "Headline to analyze" },
+                        context: { type: "string", description: "Content context" },
+                    },
+                    required: ["headline"],
                 },
-                required: ["headline"],
             },
-        },
-        {
-            name: "ai_search_content_optimization",
-            description: "Optimize content specifically for AI search engines (ChatGPT, Perplexity, Grok)",
-            inputSchema: {
-                type: "object",
-                properties: {
-                    content: { type: "string", description: "Content to optimize" },
-                    query: { type: "string", description: "Target search query" },
+            {
+                name: "ai_search_content_optimization",
+                description: "Optimize content specifically for AI search engines (ChatGPT, Perplexity, Grok)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        content: { type: "string", description: "Content to optimize" },
+                        query: { type: "string", description: "Target search query" },
+                    },
+                    required: ["content", "query"],
                 },
-                required: ["content", "query"],
             },
-        },
-    ];
-    constructor() {
-        this.server = new Server({ name: "content-creator", version: "2.0.1" }, { capabilities: { tools: {} } });
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: this.tools,
-        }));
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args = {} } = request.params;
-            try {
-                switch (name) {
-                    case "seo_content_generation": {
-                        const argsObj = args;
-                        const topic = argsObj.topic || "";
-                        const contentType = argsObj.contentType || "blog";
-                        const wordCount = argsObj.wordCount || 500;
-                        const targetAudience = argsObj.targetAudience || "general";
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        topic,
-                                        contentType,
-                                        wordCount,
-                                        targetAudience,
-                                        optimized: true,
-                                        sections: [
-                                            {
-                                                heading: "Introduction",
-                                                words: Math.floor(wordCount * 0.2),
-                                            },
-                                            {
-                                                heading: "Main Content",
-                                                words: Math.floor(wordCount * 0.5),
-                                            },
-                                            {
-                                                heading: "Conclusion",
-                                                words: Math.floor(wordCount * 0.3),
-                                            },
-                                        ],
-                                        keywords: [
-                                            topic,
-                                            `${topic} guide`,
-                                            `best ${topic}`,
-                                            `how to ${topic}`,
-                                        ],
-                                        metaDescription: `Learn everything about ${topic} in our comprehensive guide. Expert tips for ${targetAudience}.`,
-                                    }, null, 2),
-                                },
-                            ],
-                        };
-                    }
-                    case "keyword_optimization": {
-                        const argsObj = args;
-                        const content = argsObj.content || "";
-                        const primaryKeyword = argsObj.primaryKeyword || "";
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        originalLength: content.length,
-                                        optimized: true,
-                                        keywordDensity: 2.1,
-                                        suggestions: [
-                                            `Add "${primaryKeyword}" to first paragraph`,
-                                            `Include in H2 heading`,
-                                            `Add to meta description`,
-                                            `Include semantic variations`,
-                                        ],
-                                    }, null, 2),
-                                },
-                            ],
-                        };
-                    }
-                    case "meta_description_generator": {
-                        const argsObj = args;
-                        const pageTitle = argsObj.pageTitle || "";
-                        const pageContent = argsObj.pageContent || "";
-                        const targetKeyword = argsObj.targetKeyword || "";
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        title: pageTitle,
-                                        metaDescription: `${pageTitle}: ${pageContent.slice(0, 100)}... Expert guide on ${targetKeyword}.`,
-                                        characterCount: 155,
-                                        optimized: true,
-                                    }, null, 2),
-                                },
-                            ],
-                        };
-                    }
-                    case "headline_analyzer": {
-                        const { headline, context } = args;
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        headline,
-                                        context,
-                                        score: 85,
-                                        analysis: {
-                                            clarity: "Good",
-                                            emotion: "Moderate",
-                                            power: "Strong",
-                                            length: "Optimal",
-                                        },
-                                        suggestions: [
-                                            "Add numbers for better CTR",
-                                            "Include power words",
-                                            "Consider emotional triggers",
-                                        ],
-                                    }, null, 2),
-                                },
-                            ],
-                        };
-                    }
-                    case "ai_search_content_optimization": {
-                        const { content, query } = args;
-                        return {
-                            content: [
-                                {
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        query,
-                                        optimized: true,
-                                        structured: true,
-                                        sections: [
-                                            "Direct answer to query",
-                                            "Step-by-step explanation",
-                                            "Key points with examples",
-                                            "Summary with call to action",
-                                        ],
-                                        recommendations: [
-                                            "Use clear H2-H4 headings",
-                                            "Include numbered lists for citations",
-                                            "Add specific statistics",
-                                            "E-E-A-T signals (author, dates)",
-                                        ],
-                                    }, null, 2),
+        ];
+        this.handlers = {
+            "seo_content_generation": async (args) => {
+                const argsObj = args;
+                const topic = argsObj.topic || "";
+                const contentType = argsObj.contentType || "blog";
+                const wordCount = argsObj.wordCount || 500;
+                const targetAudience = argsObj.targetAudience || "general";
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                topic,
+                                contentType,
+                                wordCount,
+                                targetAudience,
+                                optimized: true,
+                                sections: [
+                                    {
+                                        heading: "Introduction",
+                                        words: Math.floor(wordCount * 0.2),
+                                    },
+                                    {
+                                        heading: "Main Content",
+                                        words: Math.floor(wordCount * 0.5),
+                                    },
+                                    {
+                                        heading: "Conclusion",
+                                        words: Math.floor(wordCount * 0.3),
+                                    },
+                                ],
+                                keywords: [
+                                    topic,
+                                    `${topic} guide`,
+                                    `best ${topic}`,
+                                    `how to ${topic}`,
+                                ],
+                                metaDescription: `Learn everything about ${topic} in our comprehensive guide. Expert tips for ${targetAudience}.`,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            },
+            "keyword_optimization": async (args) => {
+                const argsObj = args;
+                const content = argsObj.content || "";
+                const primaryKeyword = argsObj.primaryKeyword || "";
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                originalLength: content.length,
+                                optimized: true,
+                                keywordDensity: 2.1,
+                                suggestions: [
+                                    `Add "${primaryKeyword}" to first paragraph`,
+                                    `Include in H2 heading`,
+                                    `Add to meta description`,
+                                    `Include semantic variations`,
+                                ],
+                            }, null, 2),
+                        },
+                    ],
+                };
+            },
+            "meta_description_generator": async (args) => {
+                const argsObj = args;
+                const pageTitle = argsObj.pageTitle || "";
+                const pageContent = argsObj.pageContent || "";
+                const targetKeyword = argsObj.targetKeyword || "";
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                title: pageTitle,
+                                metaDescription: `${pageTitle}: ${pageContent.slice(0, 100)}... Expert guide on ${targetKeyword}.`,
+                                characterCount: 155,
+                                optimized: true,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            },
+            "headline_analyzer": async (args) => {
+                const { headline, context } = args;
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                headline,
+                                context,
+                                score: 85,
+                                analysis: {
+                                    clarity: "Good",
+                                    emotion: "Moderate",
+                                    power: "Strong",
+                                    length: "Optimal",
                                 },
-                            ],
-                        };
-                    }
-                    default:
-                        throw new Error(`Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
+                                suggestions: [
+                                    "Add numbers for better CTR",
+                                    "Include power words",
+                                    "Consider emotional triggers",
+                                ],
+                            }, null, 2),
+                        },
+                    ],
+                };
+            },
+            "ai_search_content_optimization": async (args) => {
+                const { content, query } = args;
                 return {
-                    content: [{ type: "text", text: `Error: ${error}` }],
-                    isError: true,
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                query,
+                                optimized: true,
+                                structured: true,
+                                sections: [
+                                    "Direct answer to query",
+                                    "Step-by-step explanation",
+                                    "Key points with examples",
+                                    "Summary with call to action",
+                                ],
+                                recommendations: [
+                                    "Use clear H2-H4 headings",
+                                    "Include numbered lists for citations",
+                                    "Add specific statistics",
+                                    "E-E-A-T signals (author, dates)",
+                                ],
+                            }, null, 2),
+                        },
+                    ],
                 };
-            }
-        });
-    }
-    async run() {
-        const transport = new StdioServerTransport();
-        await this.server.connect(transport);
+            },
+        };
+        this.setupToolHandlers();
     }
 }
 const entryPoint = path.resolve(process.argv[1] ?? "");
 if (entryPoint && fileURLToPath(import.meta.url) === entryPoint) {
     const server = new SEOCopywriterServer();
-    server.run();
+    server.run("content-creator").catch((err) => { frameworkLogger.log("content-creator", "run", "error", { error: err instanceof Error ? err.message : String(err) }); });
 }
 export { SEOCopywriterServer };

package/dist/mcps/knowledge-skills/database-design.server.d.ts

@@ -4,10 +4,9 @@
  * Knowledge skill for database architecture, schema optimization,
  * query performance analysis, and data modeling best practices
  */
-declare class XrayDatabaseDesignServer {
-    private server;
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+declare class XrayDatabaseDesignServer extends XrayKnowledgeSkillBase {
     constructor();
-    private setupToolHandlers;
     private analyzeSchema;
     private optimizeQuery;
     private designDataModel;
@@ -38,6 +37,5 @@ declare class XrayDatabaseDesignServer {
     private generateRollbackScript;
     private toTableName;
     private getIssueSeverityIcon;
-    run(): Promise<void>;
 }
 export { XrayDatabaseDesignServer };