0xray 4.0.12 → 4.0.13

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

@@ -1,454 +0,0 @@
-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

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,167 +0,0 @@
-/**
- * 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

@@ -1,15 +0,0 @@
-/**
- * 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 };