0xray 4.0.13 → 4.0.15

package/dist/mcps/knowledge-skills/skill-invocation.server.js

@@ -0,0 +1,454 @@
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { XrayKnowledgeSkillBase } from "../shared/knowledge-skill-base.js";
+import * as fs from "fs";
+import { fileURLToPath } from "url";
+import { randomUUID } from "crypto";
+import { mcpClientManager } from "../mcp-client.js";
+import { frameworkLogger } from "../../core/framework-logger.js";
+import { skillInstallCommand, skillRegistryCommand } from "../../cli/commands/skill-install.js";
+class SkillInvocationServer extends XrayKnowledgeSkillBase {
+    constructor() {
+        super("skill-invocation", "3.1.0");
+        this.tools = [
+            { name: "list-skills", description: "List all available skills with descriptions", inputSchema: { type: "object", properties: { category: { type: "string", enum: ["all", "core", "registry", "knowledge"], description: "Filter by category" } } } },
+            { name: "invoke-skill", description: "Generic skill invocation tool for calling any MCP skill server", inputSchema: { type: "object", properties: { skillName: { type: "string", description: "Name of the skill to invoke (use list-skills to see available)" }, toolName: { type: "string", description: "Name of the tool within the skill to execute" }, args: { type: "object", description: "Arguments to pass to the skill tool" } }, required: ["skillName", "toolName"] } },
+            { name: "skill-code-review", description: "Invoke code review skill for comprehensive code analysis", inputSchema: { type: "object", properties: { code: { type: "string", description: "Code to analyze" }, language: { type: "string", description: "Programming language" }, context: { type: "object", description: "Additional context" } }, required: ["code"] } },
+            { name: "skill-security-audit", description: "Invoke security audit skill for vulnerability scanning", inputSchema: { type: "object", properties: { files: { type: "array", items: { type: "string" }, description: "Files to audit" }, severity: { type: "string", enum: ["low", "medium", "high", "critical"], description: "Minimum severity level" } }, required: ["files"] } },
+            { name: "skill-performance-optimization", description: "Invoke performance optimization skill for bottleneck analysis", inputSchema: { type: "object", properties: { code: { type: "string", description: "Code to analyze" }, language: { type: "string", description: "Programming language" }, metrics: { type: "array", items: { type: "string" }, description: "Performance metrics to analyze" } }, required: ["code"] } },
+            { name: "skill-testing-strategy", description: "Invoke testing strategy skill for test planning", inputSchema: { type: "object", properties: { code: { type: "string", description: "Code to analyze for testing" }, existingTests: { type: "array", items: { type: "string" }, description: "Existing test files" }, requirements: { type: "object", description: "Testing requirements and constraints" } }, required: ["code"] } },
+            { name: "skill-project-analysis", description: "Invoke project analysis skill for codebase insights", inputSchema: { type: "object", properties: { scope: { type: "string", enum: ["full", "directory", "file"], description: "Analysis scope" }, analysis: { type: "array", items: { type: "string" }, description: "Types of analysis to perform" } } } },
+            { name: "skill-database-design", description: "Invoke database design skill for schema design and query optimization", inputSchema: { type: "object", properties: { schema: { type: "string", description: "Database schema or entities" }, databaseType: { type: "string", enum: ["postgresql", "mysql", "mongodb", "dynamodb"], description: "Target database type" } }, required: ["schema"] } },
+            { name: "skill-devops-deployment", description: "Invoke DevOps deployment skill for CI/CD and infrastructure", inputSchema: { type: "object", properties: { projectType: { type: "string", description: "Type of project" }, cloudProvider: { type: "string", enum: ["aws", "gcp", "azure"], description: "Target cloud provider" } }, required: ["projectType"] } },
+            { name: "skill-api-design", description: "Invoke API design skill for REST/GraphQL endpoints", inputSchema: { type: "object", properties: { resources: { type: "array", items: { type: "string" }, description: "API resources" }, style: { type: "string", enum: ["rest", "graphql"], description: "API style" } }, required: ["resources"] } },
+            { name: "skill-ui-ux-design", description: "Invoke UI/UX design skill for component design", inputSchema: { type: "object", properties: { component: { type: "string", description: "Component to design" }, framework: { type: "string", enum: ["react", "vue", "angular", "svelte"], description: "Target framework" } }, required: ["component"] } },
+            { name: "skill-documentation-generation", description: "Invoke documentation skill for API docs and README", inputSchema: { type: "object", properties: { type: { type: "string", enum: ["api", "readme", "guide"], description: "Documentation type" }, code: { type: "string", description: "Code to document" } }, required: ["type"] } },
+            { name: "skill-storyteller", description: "Invoke storyteller skill for writing reflections, sagas, and journeys", inputSchema: { type: "object", properties: { storyType: { type: "string", enum: ["reflection", "saga", "journey", "narrative"], description: "Type of story to write" }, title: { type: "string", description: "Title for the story" }, context: { type: "object", description: "Context including commits, changes, metadata" }, framework: { type: "string", enum: ["three_act_structure", "hero_journey", "spiral"], description: "Storytelling framework to use" } }, required: ["storyType"] } },
+            { name: "install-skill", description: "Install skills from the registry or any git repo", inputSchema: { type: "object", properties: { source: { type: "string", description: "Source name or git URL to install skills from" }, path: { type: "string", description: "Subdirectory in repo containing skills" }, force: { type: "boolean", description: "Reinstall even if already installed" } }, required: ["source"] } },
+            { name: "skill-registry-list", description: "List all available skill registry sources", inputSchema: { type: "object", properties: {} } },
+            { name: "skill-registry-add", description: "Add a new source to the skills registry", inputSchema: { type: "object", properties: { name: { type: "string", description: "Unique source name" }, url: { type: "string", description: "Repository URL" }, desc: { type: "string", description: "Short description" }, license: { type: "string", description: "License type" } }, required: ["name", "url"] } },
+            { name: "skill-registry-remove", description: "Remove a source from the skills registry", inputSchema: { type: "object", properties: { name: { type: "string", description: "Source name to remove" } }, required: ["name"] } },
+        ];
+        this.handlers = {
+            "list-skills": async (args) => this.handleListSkills(args),
+            "invoke-skill": async (args) => this.handleInvokeSkill(args),
+            "skill-code-review": async (args) => this.handleSkillCodeReview(args),
+            "skill-security-audit": async (args) => this.handleSkillSecurityAudit(args),
+            "skill-performance-optimization": async (args) => this.handleSkillPerformanceOptimization(args),
+            "skill-testing-strategy": async (args) => this.handleSkillTestingStrategy(args),
+            "skill-project-analysis": async (args) => this.handleSkillProjectAnalysis(args),
+            "skill-database-design": async (args) => this.handleSkillDatabaseDesign(args),
+            "skill-devops-deployment": async (args) => this.handleSkillDevopsDeployment(args),
+            "skill-api-design": async (args) => this.handleSkillApiDesign(args),
+            "skill-ui-ux-design": async (args) => this.handleSkillUiUxDesign(args),
+            "skill-documentation-generation": async (args) => this.handleSkillDocumentationGeneration(args),
+            "skill-storyteller": async (args) => this.handleSkillStoryteller(args),
+            "install-skill": async (args) => this.handleInstallSkill(args),
+            "skill-registry-list": async () => this.handleSkillRegistryList(),
+            "skill-registry-add": async (args) => this.handleSkillRegistryAdd(args),
+            "skill-registry-remove": async (args) => this.handleSkillRegistryRemove(args),
+        };
+        this.setupToolHandlers();
+    }
+    // setupToolHandlers removed — handled by XrayKnowledgeSkillBase via this.tools + this.handlers
+    skillMetrics = new Map();
+    /**
+     * Record skill invocation outcome for adaptive learning
+     */
+    recordSkillOutcome(originalSkill, resolvedSkill, toolName, duration, result, error) {
+        const key = `${resolvedSkill}:${toolName}`;
+        const existing = this.skillMetrics.get(key) || { success: 0, failure: 0, avgDuration: 0 };
+        const totalInvocations = existing.success + existing.failure;
+        const newAvgDuration = totalInvocations > 0
+            ? (existing.avgDuration * totalInvocations + duration) / (totalInvocations + 1)
+            : duration;
+        if (error) {
+            existing.failure++;
+        }
+        else {
+            existing.success++;
+            existing.avgDuration = newAvgDuration;
+        }
+        this.skillMetrics.set(key, existing);
+        // Log for persistence (simplified - in production would write to analytics)
+        if (existing.failure > 3 && (existing.failure / (existing.success + existing.failure)) > 0.5) {
+            frameworkLogger.log("skill-invocation", "low-performing-skill", "warning", { skill: resolvedSkill, tool: toolName, failureRate: (existing.failure / (existing.success + existing.failure)).toFixed(2) });
+        }
+    }
+    async handleListSkills(args) {
+        const { category = "all" } = args;
+        const coreSkills = [
+            "code-review", "security-audit", "performance-optimization",
+            "testing-strategy", "researcher", "framework-help",
+        ];
+        const registrySkills = [
+            "code-reviewer", "architect", "refactorer",
+            "security-auditor", "code-reviewer", "testing-lead",
+            "strategist", "skill-invocation",
+        ];
+        const knowledgeSkills = [
+            "architecture-patterns", "strategist", "tech-writer", "storyteller",
+            "seo-consultant", "content-creator", "growth-strategist",
+            "bug-triage-specialist", "log-monitor",
+            "mobile-development", "git-workflow", "session-management",
+            "code-analyzer", "refactoring-strategies", "project-analysis",
+            "testing-best-practices", "database-design", "devops-deployment",
+            "api-design", "ui-ux-design", "database-engineer",
+        ];
+        let skills;
+        switch (category) {
+            case "core":
+                skills = coreSkills;
+                break;
+            case "registry":
+                skills = registrySkills;
+                break;
+            case "knowledge":
+                skills = knowledgeSkills;
+                break;
+            default:
+                skills = [...coreSkills, ...registrySkills, ...knowledgeSkills];
+        }
+        const lines = [
+            `Available Skills (${skills.length}):`,
+            "",
+            ...skills.sort().map(s => `  - ${s}`),
+        ];
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+    }
+    async handleInvokeSkill(args) {
+        const { skillName, toolName, args: toolArgs = {} } = args;
+        const skillAliases = {
+            "architect": "architecture-patterns",
+            "architect-tools": "architect",
+            "backend-engineer": "api-design",
+            "code-reviewer": "code-review",
+            "database-engineer": "database-design",
+            "devops-engineer": "devops-deployment",
+            "mobile-developer": "mobile-development",
+            "performance-engineer": "performance-optimization",
+            "security-auditor": "security-audit",
+            "testing-lead": "testing-strategy",
+            "tech-writer": "documentation-generation",
+            "frontend-ui-ux-engineer": "ui-ux-design",
+            "frontend-engineer": "project-analysis",
+            "storyteller": "storyteller",
+        };
+        const resolvedSkill = skillAliases[skillName] || skillName;
+        const availableServers = [
+            "code-review", "security-audit", "performance-optimization",
+            "testing-strategy", "researcher", "skill-invocation",
+            "framework-help", "session-management", "code-analyzer",
+            "code-reviewer", "architect", "researcher",
+            "architect", "bug-triage-specialist", "log-monitor",
+            "code-reviewer", "security-auditor", "refactorer",
+            "growth-strategist", "strategist", "devops-deployment",
+            "database-design", "tech-writer", "documentation-generation",
+            "mobile-development", "seo-consultant",
+            "git-workflow", "content-creator", "ui-ux-design",
+            "multimodal-looker", "refactoring-strategies",
+            "project-analysis", "testing-best-practices",
+            "architecture-patterns", "storyteller",
+        ];
+        if (!availableServers.includes(resolvedSkill)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Skill "${skillName}" not found. Available skills: ${availableServers.join(", ")}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        try {
+            // Track skill usage for adaptive learning
+            const skillStartTime = Date.now();
+            const result = await mcpClientManager.callServerTool(resolvedSkill, toolName, toolArgs);
+            // Record outcome for adaptive learning (success = no error)
+            const duration = Date.now() - skillStartTime;
+            this.recordSkillOutcome(skillName, resolvedSkill, toolName, duration, result);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Skill ${skillName} invoked successfully with tool ${toolName}`,
+                    },
+                    {
+                        type: "text",
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            // Record failure for adaptive learning
+            this.recordSkillOutcome(skillName, resolvedSkill, toolName, 0, null, error instanceof Error ? error.message : String(error));
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error invoking skill "${skillName}": ${error instanceof Error ? error.message : String(error)}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    async handleSkillCodeReview(args) {
+        const result = await mcpClientManager.callServerTool("code-review", "analyze_code_quality", args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Code review analysis completed:",
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleSkillSecurityAudit(args) {
+        const result = await mcpClientManager.callServerTool("security-audit", "scan_vulnerabilities", args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Security audit completed:",
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleSkillPerformanceOptimization(args) {
+        const result = await mcpClientManager.callServerTool("performance-optimization", "analyze_performance", args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Performance analysis completed:",
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleSkillTestingStrategy(args) {
+        const result = await mcpClientManager.callServerTool("testing-strategy", "analyze_test_coverage", args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Testing strategy analysis completed:",
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleSkillProjectAnalysis(args) {
+        const result = await mcpClientManager.callServerTool("researcher", "analyze-project-health", args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Project analysis completed:",
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleSkillDatabaseDesign(args) {
+        const result = await mcpClientManager.callServerTool("database-design", "schema_analysis", args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Database design analysis completed:",
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleSkillDevopsDeployment(args) {
+        const result = await mcpClientManager.callServerTool("devops-deployment", "pipeline_generation", args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "DevOps deployment configuration completed:",
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleSkillApiDesign(args) {
+        const result = await mcpClientManager.callServerTool("api-design", "endpoint_design", args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "API design completed:",
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleSkillUiUxDesign(args) {
+        const result = await mcpClientManager.callServerTool("ui-ux-design", "design_component", args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "UI/UX design completed:",
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleSkillDocumentationGeneration(args) {
+        const result = await mcpClientManager.callServerTool("documentation-generation", "generate_documentation", args);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Documentation generation completed:",
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async handleSkillStoryteller(args) {
+        const { storyType, title, context, framework } = args;
+        const result = await mcpClientManager.callServerTool("storyteller", `write_${storyType}`, { title, context, framework });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Storyteller ${storyType} completed:`,
+                },
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    async captureConsole(fn) {
+        const chunks = [];
+        const origLog = console.log;
+        console.log = (...args) => chunks.push(args.map(String).join(" "));
+        try {
+            await fn();
+        }
+        finally {
+            console.log = origLog;
+        }
+        return chunks.join("\n");
+    }
+    async handleInstallSkill(args) {
+        const opts = {};
+        if (args.path !== undefined)
+            opts.path = args.path;
+        if (args.force !== undefined)
+            opts.force = args.force;
+        const output = await this.captureConsole(() => skillInstallCommand(args.source, opts));
+        return { content: [{ type: "text", text: output || "Skill installation completed." }] };
+    }
+    async handleSkillRegistryList() {
+        const output = await this.captureConsole(() => skillRegistryCommand("list"));
+        return { content: [{ type: "text", text: output || "No registry sources configured." }] };
+    }
+    async handleSkillRegistryAdd(args) {
+        const registryArgs = { name: args.name, url: args.url };
+        if (args.desc !== undefined)
+            registryArgs.desc = args.desc;
+        if (args.license !== undefined)
+            registryArgs.license = args.license;
+        const output = await this.captureConsole(() => skillRegistryCommand("add", registryArgs));
+        return { content: [{ type: "text", text: output || "Source added." }] };
+    }
+    async handleSkillRegistryRemove(args) {
+        const output = await this.captureConsole(() => skillRegistryCommand("remove", { name: args.name }));
+        return { content: [{ type: "text", text: output || "Source removed." }] };
+    }
+    // run() removed — handled by XrayKnowledgeSkillBase
+    /**
+     * Run as HTTP server using Streamable HTTP transport (for Grok CLI compatibility).
+     */
+    async runHttp(port = parseInt(process.env.MCP_PORT ?? "3200", 10)) {
+        const app = createMcpExpressApp();
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: () => randomUUID(),
+        });
+        await this.server.connect(transport);
+        app.post("/mcp", async (req, res) => {
+            try {
+                await transport.handleRequest(req, res, req.body);
+            }
+            catch (error) {
+                frameworkLogger.log("skill-invocation", "http-handler-error", "error", { error: String(error) });
+                if (!res.headersSent) {
+                    res.status(500).json({ jsonrpc: "2.0", error: { code: -32603, message: "Internal error" }, id: null });
+                }
+            }
+        });
+        app.get("/health", (_req, res) => {
+            res.json({ status: "ok", server: "skill-invocation" });
+        });
+        app.listen(port, () => {
+            frameworkLogger.log("skill-invocation", "http-listening", "info", { port });
+        });
+        process.on("SIGINT", () => { transport.close(); process.exit(0); });
+        process.on("SIGTERM", () => { transport.close(); process.exit(0); });
+    }
+}
+// Start the server if this file is run directly
+const entryPoint = fs.realpathSync(process.argv[1] ?? "");
+if (entryPoint && fileURLToPath(import.meta.url) === entryPoint) {
+    // If --port or MCP_PORT is set, use HTTP transport (for Grok CLI compatibility)
+    const cliPort = process.argv.find((a) => a.startsWith("--port="))?.split("=")[1];
+    const port = parseInt(cliPort ?? process.env.MCP_PORT ?? "", 10);
+    if (!isNaN(port)) {
+        const server = new SkillInvocationServer();
+        server.runHttp(port).catch((error) => {
+            frameworkLogger.log("skill-invocation", "http-startup-error", "error", { error: String(error) });
+            process.exit(1);
+        });
+    }
+    else {
+        const server = new SkillInvocationServer();
+        server.run().catch((error) => {
+            frameworkLogger.log("skill-invocation", "fatal-startup-error", "error", { error: String(error) });
+            process.exit(1);
+        });
+    }
+}
+export { SkillInvocationServer };

package/dist/mcps/knowledge-skills/storyteller.server.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Storyteller MCP Server
+ *
+ * Returns storyteller SKILL.md guidance plus a session-aware writing prompt.
+ * The host LLM writes the story; this server supplies the contract.
+ */
+import { XrayKnowledgeSkillBase } from '../shared/knowledge-skill-base.js';
+declare class StorytellerServer extends XrayKnowledgeSkillBase {
+    constructor();
+}
+export { StorytellerServer };

package/dist/mcps/knowledge-skills/storyteller.server.js

@@ -0,0 +1,167 @@
+/**
+ * Storyteller MCP Server
+ *
+ * Returns storyteller SKILL.md guidance plus a session-aware writing prompt.
+ * The host LLM writes the story; this server supplies the contract.
+ */
+import { execSync } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { XrayKnowledgeSkillBase } from '../shared/knowledge-skill-base.js';
+const STORY_TYPES = ['reflection', 'saga', 'journey', 'narrative'];
+function resolveSkillMd() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        join(here, '../../../skills/storyteller/SKILL.md'),
+        join(here, '../../skills/storyteller/SKILL.md'),
+        join(process.cwd(), 'node_modules/0xray/dist/skills/storyteller/SKILL.md'),
+        join(process.cwd(), 'node_modules/xray/dist/skills/storyteller/SKILL.md'),
+    ];
+    for (const path of candidates) {
+        if (existsSync(path)) {
+            return readFileSync(path, 'utf-8');
+        }
+    }
+    return '# Storyteller\n\nWrite warmly candid technical reflections with scene-first openings.';
+}
+function getStoryMeta(storyType) {
+    const defaults = {
+        reflection: {
+            location: 'docs/reflections/',
+            min_words: 2000,
+            ideal_words: 5000,
+            framework: 'three_act_structure',
+        },
+        saga: {
+            location: 'docs/reflections/deep/',
+            min_words: 5000,
+            ideal_words: 15000,
+            framework: 'hero_journey',
+        },
+        journey: {
+            location: 'docs/reflections/deep/',
+            min_words: 1500,
+            ideal_words: 4000,
+            framework: 'three_act_structure',
+        },
+        narrative: {
+            location: 'docs/reflections/',
+            min_words: 1000,
+            ideal_words: 3000,
+            framework: 'three_act_structure',
+        },
+    };
+    return defaults[storyType];
+}
+function gitContext() {
+    try {
+        const commits = execSync('git log --oneline -20 2>/dev/null', { encoding: 'utf-8' });
+        const files = execSync('git diff --name-only HEAD~10 2>/dev/null || git ls-files 2>/dev/null | head -50', { encoding: 'utf-8' });
+        return `Recent commits:\n${commits}\n\nRecent files:\n${files}`;
+    }
+    catch {
+        return 'No git context available in this workspace.';
+    }
+}
+function buildPrompt(storyType, title, meta, extraContext) {
+    const contextBlock = extraContext
+        ? `\n## Provided context\n${JSON.stringify(extraContext, null, 2)}\n`
+        : '';
+    return `Write a ${storyType} titled "${title}".
+
+## Requirements
+- Framework: ${meta.framework}
+- Target length: ${meta.ideal_words} words (minimum: ${meta.min_words})
+- Save to: ${meta.location}
+- Follow storyteller SKILL.md voice (warmly candid, scene-first, no executive summary)
+- Include Key Takeaways and What Next sections
+
+## Session / repo context
+${gitContext()}
+${contextBlock}
+
+Write the complete ${storyType} now.`;
+}
+function writeStoryTool(storyType, args) {
+    const meta = getStoryMeta(storyType);
+    if (args.framework)
+        meta.framework = args.framework;
+    const title = args.title ??
+        `${storyType.charAt(0).toUpperCase() + storyType.slice(1)} - ${new Date().toISOString().split('T')[0]}`;
+    const skillMd = resolveSkillMd();
+    const prompt = buildPrompt(storyType, title, meta, args.context);
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+    const filename = `${storyType}-${slug}-${new Date().toISOString().split('T')[0]}.md`;
+    const outputPath = args.output ?? join(meta.location, filename);
+    const outputDir = join(process.cwd(), dirname(outputPath));
+    if (!existsSync(outputDir))
+        mkdirSync(outputDir, { recursive: true });
+    const fullPath = join(process.cwd(), outputPath);
+    const frontmatter = `---
+story_type: ${storyType}
+title: "${title}"
+framework: ${meta.framework}
+target_words: ${meta.ideal_words}
+---
+
+`;
+    writeFileSync(fullPath, `${frontmatter}\n${prompt}\n`, 'utf-8');
+    return {
+        content: [
+            {
+                type: 'text',
+                text: [
+                    `Storyteller ${storyType} brief prepared.`,
+                    `Output template: ${outputPath}`,
+                    '',
+                    '--- SKILL (excerpt) ---',
+                    skillMd.slice(0, 4000),
+                    skillMd.length > 4000 ? '\n...(truncated; full SKILL.md on disk)' : '',
+                    '',
+                    '--- WRITING PROMPT ---',
+                    prompt,
+                    '',
+                    'Host LLM: write the full story into the output path using the prompt above.',
+                ].join('\n'),
+            },
+        ],
+    };
+}
+class StorytellerServer extends XrayKnowledgeSkillBase {
+    constructor() {
+        super('storyteller', '1.0.0');
+        const writeSchema = {
+            type: 'object',
+            properties: {
+                title: { type: 'string', description: 'Story title' },
+                context: { type: 'object', description: 'Session context (commits, changes, notes)' },
+                framework: { type: 'string', description: 'Storytelling framework override' },
+                output: { type: 'string', description: 'Relative output path' },
+            },
+        };
+        this.tools = STORY_TYPES.map((storyType) => ({
+            name: `write_${storyType}`,
+            description: `Prepare ${storyType} story brief using storyteller SKILL.md`,
+            inputSchema: writeSchema,
+        }));
+        this.handlers = {
+            write_reflection: async (args) => writeStoryTool('reflection', args),
+            write_saga: async (args) => writeStoryTool('saga', args),
+            write_journey: async (args) => writeStoryTool('journey', args),
+            write_narrative: async (args) => writeStoryTool('narrative', args),
+        };
+        this.setupToolHandlers();
+    }
+}
+if (import.meta.url === `file://${fileURLToPath(import.meta.url)}`) {
+    const server = new StorytellerServer();
+    server.run().catch((error) => {
+        process.stderr.write(`FATAL: ${String(error)}\n`);
+        process.exit(1);
+    });
+}
+export { StorytellerServer };

package/dist/mcps/knowledge-skills/strategist.server.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Strategist MCP Server
+ *
+ * Strategic guidance and complex problem-solving for architectural decisions.
+ * Provides strategic planning, risk assessment, and technical strategy tools.
+ */
+import { XrayKnowledgeSkillBase, type ToolDefinition } from "../shared/knowledge-skill-base.js";
+declare class StrategistServer extends XrayKnowledgeSkillBase {
+    protected tools: ToolDefinition[];
+    constructor();
+    private handleStrategicGuidance;
+    private handleRiskAssessment;
+    private handleArchitectureReview;
+}
+export { StrategistServer };