@decaf-ts/mcp-server 0.0.2 → 0.0.4

package/lib/modules/mcp/mcp-module.cjs

@@ -0,0 +1,452 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codeChangeSchema = exports.documentCodeSchema = exports.VERSION = exports.PACKAGE_NAME = exports.tools = void 0;
+exports.enrich = enrich;
+exports.setWorkspaceRoot = setWorkspaceRoot;
+exports.getWorkspaceRoot = getWorkspaceRoot;
+exports.buildResourceTemplates = buildResourceTemplates;
+exports.buildDocPrompts = buildDocPrompts;
+exports.__resetWorkspaceRoot = __resetWorkspaceRoot;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const diff_1 = require("diff");
+const zod_1 = require("zod");
+const metadata_1 = require("./../../metadata.cjs");
+const decorator_tools_1 = require("./decorator-tools.cjs");
+const WORKSPACE_ROOT_ENV = "MCP_WORKSPACE_ROOT";
+const PROMPT_DIRECTORIES = [".code/prompts", ".codex/prompts"];
+const DEFAULT_PROMPT_NAME = "doc";
+const CLIENT_INTEGRATIONS = [
+    {
+        id: "vscode",
+        display: "Visual Studio Code",
+        instructions: "When interacting from Visual Studio Code, prefer the vscode://workspace/{path} resource template to fetch file contents and use the apply-code-change tool to commit edits with previewable diffs.",
+    },
+    {
+        id: "cursor",
+        display: "Cursor",
+        instructions: "Cursor clients can retrieve and update files through the cursor://workspace/{path} resource template. Always validate patches in dryRun mode before applying permanent changes.",
+    },
+    {
+        id: "copilot",
+        display: "GitHub Copilot",
+        instructions: "Use the copilot://workspace/{path} resource template to stream file content into Copilot chat sessions. Prefer returning unified diffs to maintain alignment with Copilot's diff visualization.",
+    },
+];
+const documentCodeSchema = zod_1.z
+    .object({
+    filePath: zod_1.z.string().min(1, "filePath is required"),
+    promptName: zod_1.z.string().optional(),
+    includePrompt: zod_1.z.boolean().default(true),
+    includeCode: zod_1.z.boolean().default(true),
+    includeMetadata: zod_1.z.boolean().default(true),
+    additionalContext: zod_1.z.string().optional(),
+    encoding: zod_1.z.string().default("utf8"),
+})
+    .strict();
+exports.documentCodeSchema = documentCodeSchema;
+const codeChangeSchema = zod_1.z
+    .object({
+    filePath: zod_1.z.string().min(1, "filePath is required"),
+    patch: zod_1.z.string().min(1, "patch is required"),
+    dryRun: zod_1.z.boolean().default(false),
+    showDiff: zod_1.z.boolean().default(true),
+    diffContext: zod_1.z.number().int().min(0).max(100).default(3),
+    encoding: zod_1.z.string().default("utf8"),
+})
+    .strict();
+exports.codeChangeSchema = codeChangeSchema;
+let workspaceRoot = initializeWorkspaceRoot();
+let userErrorCtor;
+class WorkspaceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WorkspaceError";
+    }
+}
+async function getUserErrorCtor() {
+    if (!userErrorCtor) {
+        try {
+            const mod = await Promise.resolve().then(() => __importStar(require("fastmcp")));
+            userErrorCtor = mod
+                .UserError;
+        }
+        catch {
+            userErrorCtor = class MCPUserError extends Error {
+                constructor(message) {
+                    super(message);
+                    this.name = "MCPUserError";
+                }
+            };
+        }
+    }
+    return userErrorCtor;
+}
+async function throwUserError(message) {
+    const Ctor = await getUserErrorCtor();
+    throw new Ctor(message);
+}
+const documentCodeTool = {
+    annotations: {
+        idempotentHint: true,
+        openWorldHint: false,
+        readOnlyHint: true,
+        title: "Document Source File",
+    },
+    description: "Generate documentation guidance for a file by combining repository prompts with the target source code.",
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute: async (input, _context) => {
+        const args = documentCodeSchema.parse(input);
+        const root = getWorkspaceRoot();
+        let filePath;
+        try {
+            filePath = resolveInWorkspace(root, args.filePath);
+        }
+        catch (error) {
+            if (error instanceof WorkspaceError) {
+                return throwUserError(error.message);
+            }
+            /* istanbul ignore next */
+            throw error;
+        }
+        if (!fs_1.default.existsSync(filePath)) {
+            return throwUserError(`Cannot document missing file at ${args.filePath}`);
+        }
+        const fileContent = fs_1.default.readFileSync(filePath, {
+            encoding: args.encoding,
+        });
+        const prompts = discoverDocPrompts(root);
+        if (!prompts.length) {
+            return throwUserError("No documentation prompts found under .code/prompts or .codex/prompts");
+        }
+        const prompt = selectPrompt(prompts, args.promptName ?? DEFAULT_PROMPT_NAME);
+        return buildDocumentationPayload({
+            filePath: args.filePath,
+            fileContent,
+            prompt,
+            includeCode: args.includeCode,
+            includePrompt: args.includePrompt,
+            includeMetadata: args.includeMetadata,
+            additionalContext: args.additionalContext,
+        });
+    },
+    name: "document-code",
+    parameters: documentCodeSchema,
+};
+const applyCodeChangeTool = {
+    annotations: {
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false,
+        readOnlyHint: false,
+        title: "Apply Code Patch",
+    },
+    description: "Apply a unified diff patch to a workspace file with optional dry-run validation and diff preview.",
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute: async (input, _context) => {
+        const args = codeChangeSchema.parse(input);
+        const root = getWorkspaceRoot();
+        let filePath;
+        try {
+            filePath = resolveInWorkspace(root, args.filePath);
+        }
+        catch (error) {
+            if (error instanceof WorkspaceError) {
+                return throwUserError(error.message);
+            }
+            throw error;
+        }
+        const original = fs_1.default.existsSync(filePath)
+            ? fs_1.default.readFileSync(filePath, args.encoding)
+            : "";
+        let patched;
+        try {
+            patched = (0, diff_1.applyPatch)(original, args.patch);
+        }
+        catch (error) {
+            return throwUserError(`Failed to apply provided patch to ${args.filePath}: ${error instanceof Error ? error.message : error}`);
+        }
+        /* istanbul ignore next */
+        if (patched === false) {
+            return throwUserError(`Failed to apply provided patch to ${args.filePath}`);
+        }
+        if (!args.dryRun) {
+            fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+            fs_1.default.writeFileSync(filePath, patched, {
+                encoding: args.encoding,
+            });
+        }
+        if (!args.showDiff) {
+            return `Patch ${args.dryRun ? "validated" : "applied"} for ${args.filePath}`;
+        }
+        const preview = (0, diff_1.createTwoFilesPatch)(args.filePath, args.filePath, original, patched, undefined, undefined, { context: args.diffContext });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Patch ${args.dryRun ? "validated" : "applied"} for ${args.filePath}`,
+                },
+                {
+                    type: "text",
+                    text: ["```diff", preview.trim(), "```"].join("\n"),
+                },
+            ],
+        };
+    },
+    name: "apply-code-change",
+    parameters: codeChangeSchema,
+};
+exports.tools = {
+    ...decorator_tools_1.decoratorTools,
+    documentCodeTool,
+    applyCodeChangeTool,
+};
+function enrich(mcp) {
+    for (const prompt of buildDocPrompts()) {
+        mcp.addPrompt(prompt);
+    }
+    for (const tool of Object.values(exports.tools)) {
+        mcp.addTool(tool);
+    }
+    for (const template of buildResourceTemplates()) {
+        mcp.addResourceTemplate(template);
+    }
+    return mcp;
+}
+exports.default = enrich;
+exports.PACKAGE_NAME = metadata_1.PACKAGE_NAME;
+exports.VERSION = metadata_1.VERSION;
+function setWorkspaceRoot(root) {
+    workspaceRoot = path_1.default.resolve(root);
+}
+function getWorkspaceRoot() {
+    return workspaceRoot;
+}
+function buildResourceTemplates() {
+    const root = getWorkspaceRoot();
+    const sharedArguments = [
+        {
+            name: "path",
+            description: "Path relative to the workspace root",
+            required: true,
+        },
+    ];
+    return [
+        {
+            name: "vscode-workspace-file",
+            description: "Expose workspace files to Visual Studio Code via vscode:// URIs",
+            uriTemplate: "vscode://workspace/{path}",
+            mimeType: "text/plain",
+            arguments: sharedArguments,
+            load: async (args) => {
+                const text = await readWorkspaceFile(root, args.path);
+                return { text };
+            },
+        },
+        {
+            name: "cursor-workspace-file",
+            description: "Expose workspace files to Cursor via cursor:// URIs",
+            uriTemplate: "cursor://workspace/{path}",
+            mimeType: "text/plain",
+            arguments: sharedArguments,
+            load: async (args) => {
+                const text = await readWorkspaceFile(root, args.path);
+                return { text };
+            },
+        },
+        {
+            name: "copilot-workspace-file",
+            description: "Expose workspace files to GitHub Copilot via copilot:// URIs",
+            uriTemplate: "copilot://workspace/{path}",
+            mimeType: "text/plain",
+            arguments: sharedArguments,
+            load: async (args) => {
+                const text = await readWorkspaceFile(root, args.path);
+                return { text };
+            },
+        },
+    ];
+}
+function initializeWorkspaceRoot() {
+    const configured = process.env[WORKSPACE_ROOT_ENV];
+    if (configured && configured.trim().length > 0) {
+        return path_1.default.resolve(configured.trim());
+    }
+    return process.cwd();
+}
+function buildDocPrompts() {
+    const root = getWorkspaceRoot();
+    const fileBasedPrompts = discoverDocPrompts(root).map((prompt) => ({
+        name: `doc/${prompt.name}`,
+        description: prompt.description,
+        load: async () => prompt.content,
+    }));
+    const integrationPrompts = CLIENT_INTEGRATIONS.map((integration) => ({
+        name: `integration/${integration.id}`,
+        description: `${integration.display} integration guidance`,
+        load: async () => `You are coordinating with ${integration.display}. ${integration.instructions}\n\nTools available:\n- document-code\n- apply-code-change\n\nEnsure responses include actionable steps for the client.`,
+    }));
+    return [...fileBasedPrompts, ...integrationPrompts];
+}
+function resolveInWorkspace(root, targetPath) {
+    const resolved = path_1.default.isAbsolute(targetPath)
+        ? path_1.default.normalize(targetPath)
+        : path_1.default.resolve(root, targetPath);
+    const relative = path_1.default.relative(root, resolved);
+    if (relative.startsWith("..") || path_1.default.isAbsolute(relative)) {
+        throw new WorkspaceError(`Path ${targetPath} escapes the workspace root at ${root}`);
+    }
+    return resolved;
+}
+async function readWorkspaceFile(root, target) {
+    try {
+        const absolute = resolveInWorkspace(root, target);
+        return fs_1.default.readFileSync(absolute, "utf8");
+    }
+    catch (error) {
+        if (error instanceof WorkspaceError) {
+            await throwUserError(error.message);
+        }
+        /* istanbul ignore next */
+        throw error;
+    }
+}
+function discoverDocPrompts(root) {
+    const discovered = [];
+    for (const directory of PROMPT_DIRECTORIES) {
+        const promptDir = path_1.default.join(root, directory);
+        if (!fs_1.default.existsSync(promptDir) || !fs_1.default.statSync(promptDir).isDirectory()) {
+            continue;
+        }
+        for (const entry of fs_1.default.readdirSync(promptDir)) {
+            const fullPath = path_1.default.join(promptDir, entry);
+            if (!fs_1.default.statSync(fullPath).isFile())
+                continue;
+            const name = path_1.default.parse(entry).name;
+            const content = fs_1.default.readFileSync(fullPath, "utf8");
+            const title = toTitleCase(name.replace(/[-_]/g, " "));
+            const description = extractDescription(content, fullPath);
+            discovered.push({
+                name,
+                title,
+                description,
+                content,
+                absolutePath: fullPath,
+            });
+        }
+    }
+    const unique = new Map();
+    for (const prompt of discovered) {
+        if (!unique.has(prompt.name)) {
+            unique.set(prompt.name, prompt);
+        }
+    }
+    return Array.from(unique.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function selectPrompt(prompts, requestedName) {
+    const direct = prompts.find((prompt) => prompt.name === requestedName);
+    if (direct)
+        return direct;
+    const fallback = prompts.find((prompt) => prompt.name === DEFAULT_PROMPT_NAME);
+    if (fallback)
+        return fallback;
+    if (!prompts.length) {
+        throw new WorkspaceError("No documentation prompts available");
+    }
+    return prompts[0];
+}
+function buildDocumentationPayload({ filePath, fileContent, prompt, includePrompt, includeCode, includeMetadata, additionalContext, }) {
+    const sections = [];
+    if (includeMetadata) {
+        sections.push(`# Documentation Request\n- prompt: ${prompt.name}\n- file: ${filePath}`);
+    }
+    if (includePrompt) {
+        sections.push(`## Prompt Guidance (${prompt.title})\n\n${prompt.content.trim()}`);
+    }
+    if (additionalContext?.trim()) {
+        sections.push(`## Additional Context\n\n${additionalContext.trim()}`);
+    }
+    if (includeCode) {
+        sections.push(`## Source\n\n\`\`\`${inferLanguageFromPath(filePath)}\n${fileContent}\n\`\`\``);
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: sections.join("\n\n"),
+            },
+        ],
+    };
+}
+function extractDescription(content, filePath) {
+    const firstLine = content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    return (firstLine?.slice(0, 240) ??
+        `Documentation prompt loaded from ${path_1.default.basename(filePath)}`);
+}
+function toTitleCase(value) {
+    return value
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+        .join(" ");
+}
+function inferLanguageFromPath(filePath) {
+    const extension = path_1.default.extname(filePath).toLowerCase();
+    switch (extension) {
+        case ".ts":
+        case ".tsx":
+            return "ts";
+        case ".js":
+        case ".jsx":
+            return "js";
+        case ".json":
+            return "json";
+        case ".md":
+            return "md";
+        default:
+            return "text";
+    }
+}
+function __resetWorkspaceRoot(root) {
+    setWorkspaceRoot(root);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mcp-module.js","sourceRoot":"","sources":["../../../src/modules/mcp/mcp-module.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkQA,wBAcC;AAMD,4CAEC;AAED,4CAEC;AAED,wDA+CC;AAUD,0CAkBC;AAkLD,oDAEC;AA7hBD,4CAAoB;AACpB,gDAAwB;AAExB,+BAAuD;AACvD,6BAAwB;AACxB,mDAAmE;AACnE,2DAAmD;AAEnD,MAAM,kBAAkB,GAAG,oBAAoB,CAAC;AAChD,MAAM,kBAAkB,GAAG,CAAC,eAAe,EAAE,gBAAgB,CAAC,CAAC;AAC/D,MAAM,mBAAmB,GAAG,KAAK,CAAC;AAClC,MAAM,mBAAmB,GAAG;IAC1B;QACE,EAAE,EAAE,QAAQ;QACZ,OAAO,EAAE,oBAAoB;QAC7B,YAAY,EACV,oMAAoM;KACvM;IACD;QACE,EAAE,EAAE,QAAQ;QACZ,OAAO,EAAE,QAAQ;QACjB,YAAY,EACV,iLAAiL;KACpL;IACD;QACE,EAAE,EAAE,SAAS;QACb,OAAO,EAAE,gBAAgB;QACzB,YAAY,EACV,iMAAiM;KACpM;CACO,CAAC;AAEX,MAAM,kBAAkB,GAAG,OAAC;KACzB,MAAM,CAAC;IACN,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,sBAAsB,CAAC;IACnD,UAAU,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,aAAa,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IACxC,WAAW,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IACtC,eAAe,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IAC1C,iBAAiB,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACxC,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;CACrC,CAAC;KACD,MAAM,EAAE,CAAC;AAqfH,gDAAkB;AAjf3B,MAAM,gBAAgB,GAAG,OAAC;KACvB,MAAM,CAAC;IACN,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,sBAAsB,CAAC;IACnD,KAAK,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,mBAAmB,CAAC;IAC7C,MAAM,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;IAClC,QAAQ,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IACnC,WAAW,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IACxD,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;CACrC,CAAC;KACD,MAAM,EAAE,CAAC;AAweiB,4CAAgB;AA/c7C,IAAI,aAAa,GAAG,uBAAuB,EAAE,CAAC;AAC9C,IAAI,aAA2D,CAAC;AAEhE,MAAM,cAAe,SAAQ,KAAK;IAChC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,gBAAgB,CAAC;IAC/B,CAAC;CACF;AAED,KAAK,UAAU,gBAAgB;IAC7B,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,wDAAa,SAAS,GAAC,CAAC;YACpC,aAAa,GAAI,GAAqD;iBACnE,SAAS,CAAC;QACf,CAAC;QAAC,MAAM,CAAC;YACP,aAAa,GAAG,MAAM,YAAa,SAAQ,KAAK;gBAC9C,YAAY,OAAe;oBACzB,KAAK,CAAC,OAAO,CAAC,CAAC;oBACf,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;gBAC7B,CAAC;aACF,CAAC;QACJ,CAAC;IACH,CAAC;IACD,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,KAAK,UAAU,cAAc,CAAC,OAAe;IAC3C,MAAM,IAAI,GAAG,MAAM,gBAAgB,EAAE,CAAC;IACtC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;AAC1B,CAAC;AAED,MAAM,gBAAgB,GAA+C;IACnE,WAAW,EAAE;QACX,cAAc,EAAE,IAAI;QACpB,aAAa,EAAE,KAAK;QACpB,YAAY,EAAE,IAAI;QAClB,KAAK,EAAE,sBAAsB;KAC9B;IACD,WAAW,EACT,yGAAyG;IAC3G,6DAA6D;IAC7D,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAA0B,EAAE;QACzD,MAAM,IAAI,GAAG,kBAAkB,CAAC,KAAK,CAAC,KAAyB,CAAC,CAAC;QACjE,MAAM,IAAI,GAAG,gBAAgB,EAAE,CAAC;QAChC,IAAI,QAAgB,CAAC;QACrB,IAAI,CAAC;YACH,QAAQ,GAAG,kBAAkB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACrD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,cAAc,EAAE,CAAC;gBACpC,OAAO,cAAc,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACvC,CAAC;YACD,0BAA0B;YAC1B,MAAM,KAAK,CAAC;QACd,CAAC;QAED,IAAI,CAAC,YAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7B,OAAO,cAAc,CAAC,mCAAmC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC5E,CAAC;QAED,MAAM,WAAW,GAAG,YAAE,CAAC,YAAY,CAAC,QAAQ,EAAE;YAC5C,QAAQ,EAAE,IAAI,CAAC,QAA0B;SAC1C,CAAC,CAAC;QACH,MAAM,OAAO,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;QAEzC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;YACpB,OAAO,cAAc,CACnB,sEAAsE,CACvE,CAAC;QACJ,CAAC;QAED,MAAM,MAAM,GAAG,YAAY,CACzB,OAAO,EACP,IAAI,CAAC,UAAU,IAAI,mBAAmB,CACvC,CAAC;QAEF,OAAO,yBAAyB,CAAC;YAC/B,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,WAAW;YACX,MAAM;YACN,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;SAC1C,CAAC,CAAC;IACL,CAAC;IACD,IAAI,EAAE,eAAe;IACrB,UAAU,EAAE,kBAAkB;CAC/B,CAAC;AAEF,MAAM,mBAAmB,GAA6C;IACpE,WAAW,EAAE;QACX,eAAe,EAAE,IAAI;QACrB,cAAc,EAAE,KAAK;QACrB,aAAa,EAAE,KAAK;QACpB,YAAY,EAAE,KAAK;QACnB,KAAK,EAAE,kBAAkB;KAC1B;IACD,WAAW,EACT,mGAAmG;IACrG,6DAA6D;IAC7D,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAmC,EAAE;QAClE,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,CAAC,KAA4B,CAAC,CAAC;QAClE,MAAM,IAAI,GAAG,gBAAgB,EAAE,CAAC;QAChC,IAAI,QAAgB,CAAC;QACrB,IAAI,CAAC;YACH,QAAQ,GAAG,kBAAkB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;QACrD,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,cAAc,EAAE,CAAC;gBACpC,OAAO,cAAc,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;YACvC,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;QAED,MAAM,QAAQ,GAAG,YAAE,CAAC,UAAU,CAAC,QAAQ,CAAC;YACtC,CAAC,CAAC,YAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,QAA0B,CAAC;YAC5D,CAAC,CAAC,EAAE,CAAC;QAEP,IAAI,OAAuB,CAAC;QAC5B,IAAI,CAAC;YACH,OAAO,GAAG,IAAA,iBAAU,EAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QAC7C,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,cAAc,CACnB,qCAAqC,IAAI,CAAC,QAAQ,KAAK,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,EAAE,CACxG,CAAC;QACJ,CAAC;QACD,0BAA0B;QAC1B,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;YACtB,OAAO,cAAc,CACnB,qCAAqC,IAAI,CAAC,QAAQ,EAAE,CACrD,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,YAAE,CAAC,SAAS,CAAC,cAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAC1D,YAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE;gBAClC,QAAQ,EAAE,IAAI,CAAC,QAA0B;aAC1C,CAAC,CAAC;QACL,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnB,OAAO,SAAS,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,QAAQ,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC/E,CAAC;QAED,MAAM,OAAO,GAAG,IAAA,0BAAmB,EACjC,IAAI,CAAC,QAAQ,EACb,IAAI,CAAC,QAAQ,EACb,QAAQ,EACR,OAAO,EACP,SAAS,EACT,SAAS,EACT,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,CAC9B,CAAC;QAEF,OAAO;YACL,OAAO,EAAE;gBACP;oBACE,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,SAAS,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,QAAQ,IAAI,CAAC,QAAQ,EAAE;iBAC5E;gBACD;oBACE,IAAI,EAAE,MAAM;oBACZ,IAAI,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,EAAE,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;iBACpD;aACF;SACsB,CAAC;IAC5B,CAAC;IACD,IAAI,EAAE,mBAAmB;IACzB,UAAU,EAAE,gBAAgB;CAC7B,CAAC;AAEW,QAAA,KAAK,GAAG;IACnB,GAAG,gCAAc;IACjB,gBAAgB;IAChB,mBAAmB;CACX,CAAC;AAEX,SAAgB,MAAM,CAAC,GAAY;IACjC,KAAK,MAAM,MAAM,IAAI,eAAe,EAAE,EAAE,CAAC;QACvC,GAAG,CAAC,SAAS,CAAC,MAAa,CAAC,CAAC;IAC/B,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,aAAK,CAAC,EAAE,CAAC;QACxC,GAAG,CAAC,OAAO,CAAC,IAAW,CAAC,CAAC;IAC3B,CAAC;IAED,KAAK,MAAM,QAAQ,IAAI,sBAAsB,EAAE,EAAE,CAAC;QAChD,GAAG,CAAC,mBAAmB,CAAC,QAAe,CAAC,CAAC;IAC3C,CAAC;IAED,OAAO,GAAG,CAAC;AACb,CAAC;AAED,kBAAe,MAAM,CAAC;AACT,QAAA,YAAY,GAAG,uBAAG,CAAC;AACnB,QAAA,OAAO,GAAG,kBAAC,CAAC;AAEzB,SAAgB,gBAAgB,CAAC,IAAY;IAC3C,aAAa,GAAG,cAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AACrC,CAAC;AAED,SAAgB,gBAAgB;IAC9B,OAAO,aAAa,CAAC;AACvB,CAAC;AAED,SAAgB,sBAAsB;IACpC,MAAM,IAAI,GAAG,gBAAgB,EAAE,CAAC;IAChC,MAAM,eAAe,GAAG;QACtB;YACE,IAAI,EAAE,MAAM;YACZ,WAAW,EAAE,qCAAqC;YAClD,QAAQ,EAAE,IAAI;SACf;KACO,CAAC;IAEX,OAAO;QACL;YACE,IAAI,EAAE,uBAAuB;YAC7B,WAAW,EACT,iEAAiE;YACnE,WAAW,EAAE,2BAA2B;YACxC,QAAQ,EAAE,YAAY;YACtB,SAAS,EAAE,eAAe;YAC1B,IAAI,EAAE,KAAK,EAAE,IAAsB,EAAE,EAAE;gBACrC,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;gBACtD,OAAO,EAAE,IAAI,EAAE,CAAC;YAClB,CAAC;SACF;QACD;YACE,IAAI,EAAE,uBAAuB;YAC7B,WAAW,EAAE,qDAAqD;YAClE,WAAW,EAAE,2BAA2B;YACxC,QAAQ,EAAE,YAAY;YACtB,SAAS,EAAE,eAAe;YAC1B,IAAI,EAAE,KAAK,EAAE,IAAsB,EAAE,EAAE;gBACrC,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;gBACtD,OAAO,EAAE,IAAI,EAAE,CAAC;YAClB,CAAC;SACF;QACD;YACE,IAAI,EAAE,wBAAwB;YAC9B,WAAW,EACT,8DAA8D;YAChE,WAAW,EAAE,4BAA4B;YACzC,QAAQ,EAAE,YAAY;YACtB,SAAS,EAAE,eAAe;YAC1B,IAAI,EAAE,KAAK,EAAE,IAAsB,EAAE,EAAE;gBACrC,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;gBACtD,OAAO,EAAE,IAAI,EAAE,CAAC;YAClB,CAAC;SACF;KACF,CAAC;AACJ,CAAC;AAED,SAAS,uBAAuB;IAC9B,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;IACnD,IAAI,UAAU,IAAI,UAAU,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC/C,OAAO,cAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;IACzC,CAAC;IACD,OAAO,OAAO,CAAC,GAAG,EAAE,CAAC;AACvB,CAAC;AAED,SAAgB,eAAe;IAC7B,MAAM,IAAI,GAAG,gBAAgB,EAAE,CAAC;IAChC,MAAM,gBAAgB,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;QACjE,IAAI,EAAE,OAAO,MAAM,CAAC,IAAI,EAAE;QAC1B,WAAW,EAAE,MAAM,CAAC,WAAW;QAC/B,IAAI,EAAE,KAAK,IAAI,EAAE,CAAC,MAAM,CAAC,OAAO;KACjC,CAAC,CAAC,CAAC;IAEJ,MAAM,kBAAkB,GAAG,mBAAmB,CAAC,GAAG,CAChD,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;QAChB,IAAI,EAAE,eAAe,WAAW,CAAC,EAAE,EAAE;QACrC,WAAW,EAAE,GAAG,WAAW,CAAC,OAAO,uBAAuB;QAC1D,IAAI,EAAE,KAAK,IAAI,EAAE,CACf,6BAA6B,WAAW,CAAC,OAAO,KAAK,WAAW,CAAC,YAAY,yHAAyH;KACzM,CAAC,CACH,CAAC;IAEF,OAAO,CAAC,GAAG,gBAAgB,EAAE,GAAG,kBAAkB,CAAC,CAAC;AACtD,CAAC;AAED,SAAS,kBAAkB,CAAC,IAAY,EAAE,UAAkB;IAC1D,MAAM,QAAQ,GAAG,cAAI,CAAC,UAAU,CAAC,UAAU,CAAC;QAC1C,CAAC,CAAC,cAAI,CAAC,SAAS,CAAC,UAAU,CAAC;QAC5B,CAAC,CAAC,cAAI,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IAEnC,MAAM,QAAQ,GAAG,cAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;IAC/C,IAAI,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,cAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC3D,MAAM,IAAI,cAAc,CACtB,QAAQ,UAAU,kCAAkC,IAAI,EAAE,CAC3D,CAAC;IACJ,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED,KAAK,UAAU,iBAAiB,CAC9B,IAAY,EACZ,MAAc;IAEd,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAClD,OAAO,YAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAwB,CAAC,CAAC;IAC7D,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,cAAc,EAAE,CAAC;YACpC,MAAM,cAAc,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QACtC,CAAC;QACD,0BAA0B;QAC1B,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,SAAS,kBAAkB,CAAC,IAAY;IACtC,MAAM,UAAU,GAAgB,EAAE,CAAC;IAEnC,KAAK,MAAM,SAAS,IAAI,kBAAkB,EAAE,CAAC;QAC3C,MAAM,SAAS,GAAG,cAAI,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC7C,IAAI,CAAC,YAAE,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,YAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;YACvE,SAAS;QACX,CAAC;QAED,KAAK,MAAM,KAAK,IAAI,YAAE,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,CAAC;YAC9C,MAAM,QAAQ,GAAG,cAAI,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC;YAC7C,IAAI,CAAC,YAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE;gBAAE,SAAS;YAE9C,MAAM,IAAI,GAAG,cAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC;YACpC,MAAM,OAAO,GAAG,YAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YAClD,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;YACtD,MAAM,WAAW,GAAG,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC;YAE1D,UAAU,CAAC,IAAI,CAAC;gBACd,IAAI;gBACJ,KAAK;gBACL,WAAW;gBACX,OAAO;gBACP,YAAY,EAAE,QAAQ;aACvB,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,GAAG,EAAqB,CAAC;IAC5C,KAAK,MAAM,MAAM,IAAI,UAAU,EAAE,CAAC;QAChC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC;YAC7B,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAC/C,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAC7B,CAAC;AACJ,CAAC;AAED,SAAS,YAAY,CAAC,OAAoB,EAAE,aAAqB;IAC/D,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,aAAa,CAAC,CAAC;IACvE,IAAI,MAAM;QAAE,OAAO,MAAM,CAAC;IAE1B,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAC3B,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,mBAAmB,CAChD,CAAC;IACF,IAAI,QAAQ;QAAE,OAAO,QAAQ,CAAC;IAE9B,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QACpB,MAAM,IAAI,cAAc,CAAC,oCAAoC,CAAC,CAAC;IACjE,CAAC;IAED,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC;AACpB,CAAC;AAED,SAAS,yBAAyB,CAAC,EACjC,QAAQ,EACR,WAAW,EACX,MAAM,EACN,aAAa,EACb,WAAW,EACX,eAAe,EACf,iBAAiB,GASlB;IACC,MAAM,QAAQ,GAAa,EAAE,CAAC;IAE9B,IAAI,eAAe,EAAE,CAAC;QACpB,QAAQ,CAAC,IAAI,CACX,sCAAsC,MAAM,CAAC,IAAI,aAAa,QAAQ,EAAE,CACzE,CAAC;IACJ,CAAC;IAED,IAAI,aAAa,EAAE,CAAC;QAClB,QAAQ,CAAC,IAAI,CACX,uBAAuB,MAAM,CAAC,KAAK,QAAQ,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CACnE,CAAC;IACJ,CAAC;IAED,IAAI,iBAAiB,EAAE,IAAI,EAAE,EAAE,CAAC;QAC9B,QAAQ,CAAC,IAAI,CAAC,4BAA4B,iBAAiB,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IACxE,CAAC;IAED,IAAI,WAAW,EAAE,CAAC;QAChB,QAAQ,CAAC,IAAI,CACX,sBAAsB,qBAAqB,CAAC,QAAQ,CAAC,KAAK,WAAW,UAAU,CAChF,CAAC;IACJ,CAAC;IAED,OAAO;QACL,OAAO,EAAE;YACP;gBACE,IAAI,EAAE,MAAM;gBACZ,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;aAC5B;SACF;KACsB,CAAC;AAC5B,CAAC;AAED,SAAS,kBAAkB,CAAC,OAAe,EAAE,QAAgB;IAC3D,MAAM,SAAS,GAAG,OAAO;SACtB,KAAK,CAAC,OAAO,CAAC;SACd,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;SAC1B,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAEnC,OAAO,CACL,SAAS,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC;QACxB,oCAAoC,cAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAC9D,CAAC;AACJ,CAAC;AAED,SAAS,WAAW,CAAC,KAAa;IAChC,OAAO,KAAK;SACT,KAAK,CAAC,KAAK,CAAC;SACZ,MAAM,CAAC,OAAO,CAAC;SACf,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;SACzE,IAAI,CAAC,GAAG,CAAC,CAAC;AACf,CAAC;AAED,SAAS,qBAAqB,CAAC,QAAgB;IAC7C,MAAM,SAAS,GAAG,cAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;IACvD,QAAQ,SAAS,EAAE,CAAC;QAClB,KAAK,KAAK,CAAC;QACX,KAAK,MAAM;YACT,OAAO,IAAI,CAAC;QACd,KAAK,KAAK,CAAC;QACX,KAAK,MAAM;YACT,OAAO,IAAI,CAAC;QACd,KAAK,OAAO;YACV,OAAO,MAAM,CAAC;QAChB,KAAK,KAAK;YACR,OAAO,IAAI,CAAC;QACd;YACE,OAAO,MAAM,CAAC;IAClB,CAAC;AACH,CAAC;AAED,SAAgB,oBAAoB,CAAC,IAAY;IAC/C,gBAAgB,CAAC,IAAI,CAAC,CAAC;AACzB,CAAC","sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\nimport type { FastMCP, ContentResult, InputPrompt, Tool } from \"fastmcp\";\nimport { applyPatch, createTwoFilesPatch } from \"diff\";\nimport { z } from \"zod\";\nimport { PACKAGE_NAME as PKG, VERSION as V } from \"../../metadata\";\nimport { decoratorTools } from \"./decorator-tools\";\n\nconst WORKSPACE_ROOT_ENV = \"MCP_WORKSPACE_ROOT\";\nconst PROMPT_DIRECTORIES = [\".code/prompts\", \".codex/prompts\"];\nconst DEFAULT_PROMPT_NAME = \"doc\";\nconst CLIENT_INTEGRATIONS = [\n  {\n    id: \"vscode\",\n    display: \"Visual Studio Code\",\n    instructions:\n      \"When interacting from Visual Studio Code, prefer the vscode://workspace/{path} resource template to fetch file contents and use the apply-code-change tool to commit edits with previewable diffs.\",\n  },\n  {\n    id: \"cursor\",\n    display: \"Cursor\",\n    instructions:\n      \"Cursor clients can retrieve and update files through the cursor://workspace/{path} resource template. Always validate patches in dryRun mode before applying permanent changes.\",\n  },\n  {\n    id: \"copilot\",\n    display: \"GitHub Copilot\",\n    instructions:\n      \"Use the copilot://workspace/{path} resource template to stream file content into Copilot chat sessions. Prefer returning unified diffs to maintain alignment with Copilot's diff visualization.\",\n  },\n] as const;\n\nconst documentCodeSchema = z\n  .object({\n    filePath: z.string().min(1, \"filePath is required\"),\n    promptName: z.string().optional(),\n    includePrompt: z.boolean().default(true),\n    includeCode: z.boolean().default(true),\n    includeMetadata: z.boolean().default(true),\n    additionalContext: z.string().optional(),\n    encoding: z.string().default(\"utf8\"),\n  })\n  .strict();\n\ntype DocumentCodeArgs = z.infer<typeof documentCodeSchema>;\n\nconst codeChangeSchema = z\n  .object({\n    filePath: z.string().min(1, \"filePath is required\"),\n    patch: z.string().min(1, \"patch is required\"),\n    dryRun: z.boolean().default(false),\n    showDiff: z.boolean().default(true),\n    diffContext: z.number().int().min(0).max(100).default(3),\n    encoding: z.string().default(\"utf8\"),\n  })\n  .strict();\n\ntype ApplyCodeChangeArgs = z.infer<typeof codeChangeSchema>;\n\ntype DocPrompt = {\n  name: string;\n  title: string;\n  description: string;\n  content: string;\n  absolutePath: string;\n};\n\ntype WorkspaceResourceTemplate = {\n  name: string;\n  description: string;\n  uriTemplate: string;\n  mimeType: string;\n  arguments: ReadonlyArray<{\n    name: string;\n    description: string;\n    required: boolean;\n  }>;\n  load: (args: { path: string }) => Promise<{ text: string }>;\n};\n\nlet workspaceRoot = initializeWorkspaceRoot();\nlet userErrorCtor: (new (message: string) => Error) | undefined;\n\nclass WorkspaceError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"WorkspaceError\";\n  }\n}\n\nasync function getUserErrorCtor(): Promise<new (message: string) => Error> {\n  if (!userErrorCtor) {\n    try {\n      const mod = await import(\"fastmcp\");\n      userErrorCtor = (mod as { UserError: new (message: string) => Error })\n        .UserError;\n    } catch {\n      userErrorCtor = class MCPUserError extends Error {\n        constructor(message: string) {\n          super(message);\n          this.name = \"MCPUserError\";\n        }\n      };\n    }\n  }\n  return userErrorCtor;\n}\n\nasync function throwUserError(message: string): Promise<never> {\n  const Ctor = await getUserErrorCtor();\n  throw new Ctor(message);\n}\n\nconst documentCodeTool: Tool<undefined, typeof documentCodeSchema> = {\n  annotations: {\n    idempotentHint: true,\n    openWorldHint: false,\n    readOnlyHint: true,\n    title: \"Document Source File\",\n  },\n  description:\n    \"Generate documentation guidance for a file by combining repository prompts with the target source code.\",\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  execute: async (input, _context): Promise<ContentResult> => {\n    const args = documentCodeSchema.parse(input as DocumentCodeArgs);\n    const root = getWorkspaceRoot();\n    let filePath: string;\n    try {\n      filePath = resolveInWorkspace(root, args.filePath);\n    } catch (error) {\n      if (error instanceof WorkspaceError) {\n        return throwUserError(error.message);\n      }\n      /* istanbul ignore next */\n      throw error;\n    }\n\n    if (!fs.existsSync(filePath)) {\n      return throwUserError(`Cannot document missing file at ${args.filePath}`);\n    }\n\n    const fileContent = fs.readFileSync(filePath, {\n      encoding: args.encoding as BufferEncoding,\n    });\n    const prompts = discoverDocPrompts(root);\n\n    if (!prompts.length) {\n      return throwUserError(\n        \"No documentation prompts found under .code/prompts or .codex/prompts\"\n      );\n    }\n\n    const prompt = selectPrompt(\n      prompts,\n      args.promptName ?? DEFAULT_PROMPT_NAME\n    );\n\n    return buildDocumentationPayload({\n      filePath: args.filePath,\n      fileContent,\n      prompt,\n      includeCode: args.includeCode,\n      includePrompt: args.includePrompt,\n      includeMetadata: args.includeMetadata,\n      additionalContext: args.additionalContext,\n    });\n  },\n  name: \"document-code\",\n  parameters: documentCodeSchema,\n};\n\nconst applyCodeChangeTool: Tool<undefined, typeof codeChangeSchema> = {\n  annotations: {\n    destructiveHint: true,\n    idempotentHint: false,\n    openWorldHint: false,\n    readOnlyHint: false,\n    title: \"Apply Code Patch\",\n  },\n  description:\n    \"Apply a unified diff patch to a workspace file with optional dry-run validation and diff preview.\",\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  execute: async (input, _context): Promise<string | ContentResult> => {\n    const args = codeChangeSchema.parse(input as ApplyCodeChangeArgs);\n    const root = getWorkspaceRoot();\n    let filePath: string;\n    try {\n      filePath = resolveInWorkspace(root, args.filePath);\n    } catch (error) {\n      if (error instanceof WorkspaceError) {\n        return throwUserError(error.message);\n      }\n      throw error;\n    }\n\n    const original = fs.existsSync(filePath)\n      ? fs.readFileSync(filePath, args.encoding as BufferEncoding)\n      : \"\";\n\n    let patched: string | false;\n    try {\n      patched = applyPatch(original, args.patch);\n    } catch (error) {\n      return throwUserError(\n        `Failed to apply provided patch to ${args.filePath}: ${error instanceof Error ? error.message : error}`\n      );\n    }\n    /* istanbul ignore next */\n    if (patched === false) {\n      return throwUserError(\n        `Failed to apply provided patch to ${args.filePath}`\n      );\n    }\n\n    if (!args.dryRun) {\n      fs.mkdirSync(path.dirname(filePath), { recursive: true });\n      fs.writeFileSync(filePath, patched, {\n        encoding: args.encoding as BufferEncoding,\n      });\n    }\n\n    if (!args.showDiff) {\n      return `Patch ${args.dryRun ? \"validated\" : \"applied\"} for ${args.filePath}`;\n    }\n\n    const preview = createTwoFilesPatch(\n      args.filePath,\n      args.filePath,\n      original,\n      patched,\n      undefined,\n      undefined,\n      { context: args.diffContext }\n    );\n\n    return {\n      content: [\n        {\n          type: \"text\",\n          text: `Patch ${args.dryRun ? \"validated\" : \"applied\"} for ${args.filePath}`,\n        },\n        {\n          type: \"text\",\n          text: [\"```diff\", preview.trim(), \"```\"].join(\"\\n\"),\n        },\n      ],\n    } satisfies ContentResult;\n  },\n  name: \"apply-code-change\",\n  parameters: codeChangeSchema,\n};\n\nexport const tools = {\n  ...decoratorTools,\n  documentCodeTool,\n  applyCodeChangeTool,\n} as const;\n\nexport function enrich(mcp: FastMCP): FastMCP {\n  for (const prompt of buildDocPrompts()) {\n    mcp.addPrompt(prompt as any);\n  }\n\n  for (const tool of Object.values(tools)) {\n    mcp.addTool(tool as any);\n  }\n\n  for (const template of buildResourceTemplates()) {\n    mcp.addResourceTemplate(template as any);\n  }\n\n  return mcp;\n}\n\nexport default enrich;\nexport const PACKAGE_NAME = PKG;\nexport const VERSION = V;\n\nexport function setWorkspaceRoot(root: string) {\n  workspaceRoot = path.resolve(root);\n}\n\nexport function getWorkspaceRoot(): string {\n  return workspaceRoot;\n}\n\nexport function buildResourceTemplates(): WorkspaceResourceTemplate[] {\n  const root = getWorkspaceRoot();\n  const sharedArguments = [\n    {\n      name: \"path\",\n      description: \"Path relative to the workspace root\",\n      required: true,\n    },\n  ] as const;\n\n  return [\n    {\n      name: \"vscode-workspace-file\",\n      description:\n        \"Expose workspace files to Visual Studio Code via vscode:// URIs\",\n      uriTemplate: \"vscode://workspace/{path}\",\n      mimeType: \"text/plain\",\n      arguments: sharedArguments,\n      load: async (args: { path: string }) => {\n        const text = await readWorkspaceFile(root, args.path);\n        return { text };\n      },\n    },\n    {\n      name: \"cursor-workspace-file\",\n      description: \"Expose workspace files to Cursor via cursor:// URIs\",\n      uriTemplate: \"cursor://workspace/{path}\",\n      mimeType: \"text/plain\",\n      arguments: sharedArguments,\n      load: async (args: { path: string }) => {\n        const text = await readWorkspaceFile(root, args.path);\n        return { text };\n      },\n    },\n    {\n      name: \"copilot-workspace-file\",\n      description:\n        \"Expose workspace files to GitHub Copilot via copilot:// URIs\",\n      uriTemplate: \"copilot://workspace/{path}\",\n      mimeType: \"text/plain\",\n      arguments: sharedArguments,\n      load: async (args: { path: string }) => {\n        const text = await readWorkspaceFile(root, args.path);\n        return { text };\n      },\n    },\n  ];\n}\n\nfunction initializeWorkspaceRoot(): string {\n  const configured = process.env[WORKSPACE_ROOT_ENV];\n  if (configured && configured.trim().length > 0) {\n    return path.resolve(configured.trim());\n  }\n  return process.cwd();\n}\n\nexport function buildDocPrompts(): InputPrompt<undefined>[] {\n  const root = getWorkspaceRoot();\n  const fileBasedPrompts = discoverDocPrompts(root).map((prompt) => ({\n    name: `doc/${prompt.name}`,\n    description: prompt.description,\n    load: async () => prompt.content,\n  }));\n\n  const integrationPrompts = CLIENT_INTEGRATIONS.map<InputPrompt<undefined>>(\n    (integration) => ({\n      name: `integration/${integration.id}`,\n      description: `${integration.display} integration guidance`,\n      load: async () =>\n        `You are coordinating with ${integration.display}. ${integration.instructions}\\n\\nTools available:\\n- document-code\\n- apply-code-change\\n\\nEnsure responses include actionable steps for the client.`,\n    })\n  );\n\n  return [...fileBasedPrompts, ...integrationPrompts];\n}\n\nfunction resolveInWorkspace(root: string, targetPath: string): string {\n  const resolved = path.isAbsolute(targetPath)\n    ? path.normalize(targetPath)\n    : path.resolve(root, targetPath);\n\n  const relative = path.relative(root, resolved);\n  if (relative.startsWith(\"..\") || path.isAbsolute(relative)) {\n    throw new WorkspaceError(\n      `Path ${targetPath} escapes the workspace root at ${root}`\n    );\n  }\n\n  return resolved;\n}\n\nasync function readWorkspaceFile(\n  root: string,\n  target: string\n): Promise<string> {\n  try {\n    const absolute = resolveInWorkspace(root, target);\n    return fs.readFileSync(absolute, \"utf8\" as BufferEncoding);\n  } catch (error) {\n    if (error instanceof WorkspaceError) {\n      await throwUserError(error.message);\n    }\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n\nfunction discoverDocPrompts(root: string): DocPrompt[] {\n  const discovered: DocPrompt[] = [];\n\n  for (const directory of PROMPT_DIRECTORIES) {\n    const promptDir = path.join(root, directory);\n    if (!fs.existsSync(promptDir) || !fs.statSync(promptDir).isDirectory()) {\n      continue;\n    }\n\n    for (const entry of fs.readdirSync(promptDir)) {\n      const fullPath = path.join(promptDir, entry);\n      if (!fs.statSync(fullPath).isFile()) continue;\n\n      const name = path.parse(entry).name;\n      const content = fs.readFileSync(fullPath, \"utf8\");\n      const title = toTitleCase(name.replace(/[-_]/g, \" \"));\n      const description = extractDescription(content, fullPath);\n\n      discovered.push({\n        name,\n        title,\n        description,\n        content,\n        absolutePath: fullPath,\n      });\n    }\n  }\n\n  const unique = new Map<string, DocPrompt>();\n  for (const prompt of discovered) {\n    if (!unique.has(prompt.name)) {\n      unique.set(prompt.name, prompt);\n    }\n  }\n\n  return Array.from(unique.values()).sort((a, b) =>\n    a.name.localeCompare(b.name)\n  );\n}\n\nfunction selectPrompt(prompts: DocPrompt[], requestedName: string): DocPrompt {\n  const direct = prompts.find((prompt) => prompt.name === requestedName);\n  if (direct) return direct;\n\n  const fallback = prompts.find(\n    (prompt) => prompt.name === DEFAULT_PROMPT_NAME\n  );\n  if (fallback) return fallback;\n\n  if (!prompts.length) {\n    throw new WorkspaceError(\"No documentation prompts available\");\n  }\n\n  return prompts[0];\n}\n\nfunction buildDocumentationPayload({\n  filePath,\n  fileContent,\n  prompt,\n  includePrompt,\n  includeCode,\n  includeMetadata,\n  additionalContext,\n}: {\n  filePath: string;\n  fileContent: string;\n  prompt: DocPrompt;\n  includePrompt: boolean;\n  includeCode: boolean;\n  includeMetadata: boolean;\n  additionalContext?: string;\n}): ContentResult {\n  const sections: string[] = [];\n\n  if (includeMetadata) {\n    sections.push(\n      `# Documentation Request\\n- prompt: ${prompt.name}\\n- file: ${filePath}`\n    );\n  }\n\n  if (includePrompt) {\n    sections.push(\n      `## Prompt Guidance (${prompt.title})\\n\\n${prompt.content.trim()}`\n    );\n  }\n\n  if (additionalContext?.trim()) {\n    sections.push(`## Additional Context\\n\\n${additionalContext.trim()}`);\n  }\n\n  if (includeCode) {\n    sections.push(\n      `## Source\\n\\n\\`\\`\\`${inferLanguageFromPath(filePath)}\\n${fileContent}\\n\\`\\`\\``\n    );\n  }\n\n  return {\n    content: [\n      {\n        type: \"text\",\n        text: sections.join(\"\\n\\n\"),\n      },\n    ],\n  } satisfies ContentResult;\n}\n\nfunction extractDescription(content: string, filePath: string): string {\n  const firstLine = content\n    .split(/\\r?\\n/)\n    .map((line) => line.trim())\n    .find((line) => line.length > 0);\n\n  return (\n    firstLine?.slice(0, 240) ??\n    `Documentation prompt loaded from ${path.basename(filePath)}`\n  );\n}\n\nfunction toTitleCase(value: string): string {\n  return value\n    .split(/\\s+/)\n    .filter(Boolean)\n    .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())\n    .join(\" \");\n}\n\nfunction inferLanguageFromPath(filePath: string): string {\n  const extension = path.extname(filePath).toLowerCase();\n  switch (extension) {\n    case \".ts\":\n    case \".tsx\":\n      return \"ts\";\n    case \".js\":\n    case \".jsx\":\n      return \"js\";\n    case \".json\":\n      return \"json\";\n    case \".md\":\n      return \"md\";\n    default:\n      return \"text\";\n  }\n}\n\nexport function __resetWorkspaceRoot(root: string) {\n  setWorkspaceRoot(root);\n}\n\nexport { documentCodeSchema, codeChangeSchema };\n"]}