@decaf-ts/mcp-server 0.0.2 → 0.0.4

package/dist/mcp-server.cjs

@@ -1,230 +1,936 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-    typeof define === 'function' && define.amd ? define(['exports'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["mcp-server"] = {}));
-})(this, (function (exports) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fs'), require('path'), require('diff'), require('zod'), require('@decaf-ts/decoration'), require('fastmcp'), require('@decaf-ts/logging')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'fs', 'path', 'diff', 'zod', '@decaf-ts/decoration', 'fastmcp', '@decaf-ts/logging'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["mcp-server"] = {}, global.fs, global.path, global.diff, global.zod, global.decoration, global.fastmcp, global.logging));
+})(this, (function (exports, fs, path, diff, zod, decoration, fastmcp, logging) { 'use strict';
 
     /**
-     * @function complexFunction
-     * @description This function takes an optional string argument and concatenates it with "Hello World".
-     * @summary Concatenates "Hello World" with a given string. Despite its name, it's a simple string concatenation operation.
-     *
-     * @param {string} [arg1="default"] - The string to append to "Hello World". If not provided, defaults to "default".
-     * @return {string} The resulting concatenated string
-     *
-     * @example
-     * // returns "Hello Worlddefault"
-     * complexFunction();
-     *
-     * @example
-     * // returns "Hello World!"
-     * complexFunction("!");
-     *
-     * @memberOf module:ts-workspace
+     * @const VERSION
+     * @name VERSION
+     * @description Represents the current version of the ts-workspace module.
+     * @summary The actual version number is replaced during the build process.
+     * @type {string}
      */
-    function complexFunction(arg1 = "default") {
-        return "Hello World" + arg1;
+    const VERSION$1 = "0.0.3";
+    const PACKAGE_NAME$1 = "##PACKAGE_NAME##";
+    try {
+        decoration.Metadata.registerLibrary(PACKAGE_NAME$1, VERSION$1);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.includes("already")) ;
+        else {
+            throw error;
+        }
+    }
+
+    function escapeRegExp(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+    function formatDecorator(spec) {
+        const args = (spec.args || []).map((arg) => JSON.stringify(arg)).join(", ");
+        return `@${spec.name}(${args})`;
+    }
+    function ensureDirectory(filePath) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    }
+    function collectDecoratorNames(classDecorators, properties) {
+        const names = new Set();
+        names.add("model");
+        for (const decorator of classDecorators || []) {
+            names.add(decorator.name);
+        }
+        for (const property of properties || []) {
+            for (const decorator of property.decorators || []) {
+                names.add(decorator.name);
+            }
+        }
+        return names;
+    }
+    function ensureImport(content, importsFrom, decorators) {
+        /* istanbul ignore next */
+        if (!decorators.size)
+            return content;
+        const importRegex = new RegExp(`import\\s+\\{([^}]+)\\}\\s+from\\s+["']${escapeRegExp(importsFrom)}["'];`);
+        const match = content.match(importRegex);
+        const sorted = Array.from(decorators).sort();
+        if (match) {
+            const existing = match[1]
+                .split(",")
+                .map((name) => name.trim())
+                .filter(Boolean);
+            const merged = Array.from(new Set([...existing, ...sorted])).sort();
+            return content.replace(importRegex, `import { ${merged.join(", ")} } from "${importsFrom}";`);
+        }
+        const importLine = `import { ${sorted.join(", ")} } from "${importsFrom}";`;
+        return `${importLine}\n\n${content}`;
+    }
+    function addPropertyBlock(property) {
+        const decorators = (property.decorators || [])
+            .map(formatDecorator)
+            .join("\n  ");
+        const decoratorBlock = decorators ? `  ${decorators}\n` : "";
+        return `${decoratorBlock}  ${property.name}: ${property.type};`;
+    }
+    function removePropertyBlock(content, propertyName) {
+        const lines = content.split(/\r?\n/);
+        const result = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            if (line.trim().startsWith(`@`) &&
+                lines[i + 1]?.includes(`${propertyName}:`)) {
+                continue;
+            }
+            if (line.includes(`${propertyName}:`)) {
+                // skip this line and any trailing blank line
+                continue;
+            }
+            result.push(line);
+        }
+        return result.join("\n");
+    }
+    function insertDecorator(content, decorator, target) {
+        const decoratorLine = formatDecorator(decorator);
+        if (target.kind === "class") {
+            const classRegex = /(export\s+class\s+[^\s{]+\s*\{)/;
+            if (content.includes(decoratorLine))
+                return content;
+            return content.replace(classRegex, `${decoratorLine}\n$1`);
+        }
+        if (!target.name)
+            return content;
+        const propertyRegex = new RegExp(`(^\\s*)(?:@.*\\n\\1)*${escapeRegExp(target.name)}:`, "m");
+        const match = propertyRegex.exec(content);
+        if (!match)
+            return content;
+        const indent = match[1] || "  ";
+        if (content.includes(`${indent}${decoratorLine}`))
+            return content;
+        return (content.slice(0, match.index) +
+            `${indent}${decoratorLine}\n` +
+            content.slice(match.index));
+    }
+    function removeDecorator(content, decoratorName, target) {
+        const decoratorRegex = new RegExp(`^\\s*@${escapeRegExp(decoratorName)}\\([^)]*\\)`, "m");
+        if (target.kind === "class") {
+            return content.replace(decoratorRegex, "");
+        }
+        if (target.name) {
+            const pattern = new RegExp(`(^\\s*@${escapeRegExp(decoratorName)}\\([^)]*\\)\\s*$\\n)(?=\\s*${escapeRegExp(target.name)}:)`, "m");
+            return content.replace(pattern, "");
+        }
+        return content;
+    }
+    function writeIfChanged(filePath, content) {
+        ensureDirectory(filePath);
+        fs.writeFileSync(filePath, content);
+    }
+    const decoratorTools = {
+        createOrUpdateModelTool: {
+            name: "create-or-update-model",
+            description: "Create or update a validation-ready model class",
+            execute: async (args) => {
+                if (!args.overwrite && fs.existsSync(args.filePath)) {
+                    throw new Error(`File already exists at ${args.filePath}`);
+                }
+                const decorators = collectDecoratorNames(args.classDecorators, args.properties);
+                let content = `@model()`;
+                for (const decorator of args.classDecorators || []) {
+                    content += `\n${formatDecorator(decorator)}`;
+                }
+                const properties = (args.properties || [])
+                    .map(addPropertyBlock)
+                    .join("\n\n");
+                content += `\nexport class ${args.className} {\n${properties ? `${properties}\n` : ""}}\n`;
+                content = ensureImport(content, args.importsFrom, decorators);
+                writeIfChanged(args.filePath, content);
+                return { filePath: args.filePath };
+            },
+        },
+        addAttributeTool: {
+            name: "add-attribute",
+            description: "Add a decorated attribute to an existing model",
+            execute: async (args) => {
+                if (!fs.existsSync(args.filePath)) {
+                    throw new Error(`Model file not found at ${args.filePath}`);
+                }
+                let content = fs.readFileSync(args.filePath, "utf8");
+                if (content.includes(`${args.attribute.name}:`)) {
+                    return { filePath: args.filePath };
+                }
+                const decorators = collectDecoratorNames(undefined, [args.attribute]);
+                content = ensureImport(content, args.importsFrom, decorators);
+                const insertionPoint = content.lastIndexOf("}");
+                const block = addPropertyBlock(args.attribute);
+                const before = content.slice(0, insertionPoint).replace(/\s*$/, "");
+                const after = content.slice(insertionPoint);
+                const updated = `${before}\n${block}\n${after}`;
+                writeIfChanged(args.filePath, updated);
+                return { filePath: args.filePath };
+            },
+        },
+        removeAttributeTool: {
+            name: "remove-attribute",
+            description: "Remove an attribute from a model class",
+            execute: async (args) => {
+                if (!fs.existsSync(args.filePath))
+                    return { filePath: args.filePath };
+                const content = fs.readFileSync(args.filePath, "utf8");
+                const updated = removePropertyBlock(content, args.attributeName);
+                writeIfChanged(args.filePath, updated);
+                return { filePath: args.filePath };
+            },
+        },
+        applyDecoratorTool: {
+            name: "apply-decorator",
+            description: "Apply a decorator to a class or property",
+            execute: async (args) => {
+                if (!fs.existsSync(args.filePath)) {
+                    throw new Error(`Model file not found at ${args.filePath}`);
+                }
+                let content = fs.readFileSync(args.filePath, "utf8");
+                const decorators = new Set([args.decorator.name]);
+                content = ensureImport(content, args.importsFrom, decorators);
+                content = insertDecorator(content, args.decorator, args.target);
+                writeIfChanged(args.filePath, content);
+                return { filePath: args.filePath };
+            },
+        },
+        removeDecoratorTool: {
+            name: "remove-decorator",
+            description: "Remove a decorator from a class or property",
+            execute: async (args) => {
+                if (!fs.existsSync(args.filePath))
+                    return { filePath: args.filePath };
+                let content = fs.readFileSync(args.filePath, "utf8");
+                content = removeDecorator(content, args.decoratorName, args.target);
+                writeIfChanged(args.filePath, content);
+                return { filePath: args.filePath };
+            },
+        },
+        scaffoldValidatorTool: {
+            name: "scaffold-validator",
+            description: "Scaffold a validator class and optional decorator",
+            execute: async (args) => {
+                const classFile = path.join(args.validatorsDir, `${args.name}.ts`);
+                ensureDirectory(classFile);
+                const classContent = `export class ${args.name} {\n  validate(value: unknown): boolean {\n    return value !== undefined;\n  }\n}\n`;
+                fs.writeFileSync(classFile, classContent);
+                let decoratorFile;
+                if (args.decoratorDir) {
+                    decoratorFile = path.join(args.decoratorDir, `${args.name}Decorator.ts`);
+                    ensureDirectory(decoratorFile);
+                    fs.writeFileSync(decoratorFile, `export function ${args.name}Decorator() {\n  return () => void 0;\n}\n`);
+                }
+                return { classFile, decoratorFile };
+            },
+        },
+        scaffoldSerializerTool: {
+            name: "scaffold-serializer",
+            description: "Scaffold a serializer class and optional registry",
+            execute: async (args) => {
+                const classFile = path.join(args.dir, `${args.name}.ts`);
+                ensureDirectory(classFile);
+                fs.writeFileSync(classFile, `export class ${args.name} {\n  serialize(value: unknown): string {\n    return JSON.stringify(value);\n  }\n}\n`);
+                let registerFile;
+                if (args.registerDir) {
+                    registerFile = path.join(args.registerDir, `${args.name}Register.ts`);
+                    ensureDirectory(registerFile);
+                    fs.writeFileSync(registerFile, `export function register${args.name}() {\n  return ${args.setDefault ? "'default'" : "'optional'"};\n}\n`);
+                }
+                return { classFile, registerFile };
+            },
+        },
+        scaffoldHashingTool: {
+            name: "scaffold-hashing",
+            description: "Scaffold a hashing function and optional registry",
+            execute: async (args) => {
+                const functionFile = path.join(args.dir, `${args.name}.ts`);
+                ensureDirectory(functionFile);
+                fs.writeFileSync(functionFile, `export function ${args.name}(value: string): string {\n  return value.split('').reverse().join('');\n}\n`);
+                let registerFile;
+                if (args.registerDir) {
+                    registerFile = path.join(args.registerDir, `${args.name}Register.ts`);
+                    ensureDirectory(registerFile);
+                    fs.writeFileSync(registerFile, `export function register${args.name}() {\n  return ${args.setDefault ? "'default'" : "'optional'"};\n}\n`);
+                }
+                return { functionFile, registerFile };
+            },
+        },
+    };
+
+    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.z
+        .object({
+        filePath: zod.z.string().min(1, "filePath is required"),
+        promptName: zod.z.string().optional(),
+        includePrompt: zod.z.boolean().default(true),
+        includeCode: zod.z.boolean().default(true),
+        includeMetadata: zod.z.boolean().default(true),
+        additionalContext: zod.z.string().optional(),
+        encoding: zod.z.string().default("utf8"),
+    })
+        .strict();
+    const codeChangeSchema = zod.z
+        .object({
+        filePath: zod.z.string().min(1, "filePath is required"),
+        patch: zod.z.string().min(1, "patch is required"),
+        dryRun: zod.z.boolean().default(false),
+        showDiff: zod.z.boolean().default(true),
+        diffContext: zod.z.number().int().min(0).max(100).default(3),
+        encoding: zod.z.string().default("utf8"),
+    })
+        .strict();
+    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 import('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.existsSync(filePath)) {
+                return throwUserError(`Cannot document missing file at ${args.filePath}`);
+            }
+            const fileContent = fs.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.existsSync(filePath)
+                ? fs.readFileSync(filePath, args.encoding)
+                : "";
+            let patched;
+            try {
+                patched = diff.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.mkdirSync(path.dirname(filePath), { recursive: true });
+                fs.writeFileSync(filePath, patched, {
+                    encoding: args.encoding,
+                });
+            }
+            if (!args.showDiff) {
+                return `Patch ${args.dryRun ? "validated" : "applied"} for ${args.filePath}`;
+            }
+            const preview = diff.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,
+    };
+    const tools = {
+        ...decoratorTools,
+        documentCodeTool,
+        applyCodeChangeTool,
+    };
+    function enrich(mcp) {
+        for (const prompt of buildDocPrompts()) {
+            mcp.addPrompt(prompt);
+        }
+        for (const tool of Object.values(tools)) {
+            mcp.addTool(tool);
+        }
+        for (const template of buildResourceTemplates()) {
+            mcp.addResourceTemplate(template);
+        }
+        return mcp;
+    }
+    const PACKAGE_NAME = PACKAGE_NAME$1;
+    const VERSION = VERSION$1;
+    function setWorkspaceRoot(root) {
+        workspaceRoot = path.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.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.isAbsolute(targetPath)
+            ? path.normalize(targetPath)
+            : path.resolve(root, targetPath);
+        const relative = path.relative(root, resolved);
+        if (relative.startsWith("..") || path.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.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.join(root, directory);
+            if (!fs.existsSync(promptDir) || !fs.statSync(promptDir).isDirectory()) {
+                continue;
+            }
+            for (const entry of fs.readdirSync(promptDir)) {
+                const fullPath = path.join(promptDir, entry);
+                if (!fs.statSync(fullPath).isFile())
+                    continue;
+                const name = path.parse(entry).name;
+                const content = fs.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.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.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";
+        }
     }
 
     /**
-     * @class Class
-     * @description A class implementing the Interface contract.
-     * @summary This class provides an implementation of the Interface contract with additional static functionality.
-     * It manages an internal state through a private property and offers both instance and static methods.
+     * @description The filename that identifies Decaf CLI modules
+     * @summary The standard filename for CLI module files where each library must export a single CliModule function
      *
-     * @param {unknown} arg1 - First argument of unknown type
-     * @param {string} arg2 - Second argument as string
-     *
-     * @implements {Interface}
+     * @const MCP_FILE_NAME
+     * @memberOf module:MCP
+     */
+    const MCP_FILE_NAME = "mcp-module";
+
+    /* istanbul ignore file */
+    /**
+     * @description Utility class for CLI operations
+     * @summary A static utility class that provides methods for loading modules, retrieving package information, and initializing CLI commands
      *
      * @example
-     * ```typescript
-     * // Create a new instance
-     * const instance = new Class('someValue', 'stringValue');
-     *
-     * // Using the generic method
-     * await instance.method<string>()
-     *   .catch(error => console.error(error));
-     *
-     * // Using the static method
-     * Class.method();
-     * ```
+     * // Initialize a Command object with package information
+     * const command = new Command();
+     * CLIUtils.initialize(command, './path/to/package');
      *
-     * @mermaid
-     * sequenceDiagram
-     *   participant Client
-     *   participant Instance
-     *   participant Static
+     * // Load a CLI module from a file
+     * const module = await CLIUtils.loadFromFile('./path/to/cli-module.js');
      *
-     *   Client->>Instance: new Class(arg1, arg2)
-     *   activate Instance
-     *   Instance-->>Client: class instance
-     *   deactivate Instance
-     *
-     *   Client->>Instance: method<T>()
-     *   activate Instance
-     *   Instance-->>Client: Promise<string>
-     *   deactivate Instance
-     *
-     *   Client->>Static: Class.method()
-     *   activate Static
-     *   Static-->>Client: void
-     *   deactivate Static
+     * @class McpUtils
      */
-    class Class {
-        constructor(arg1, arg2) {
-            console.log(arg1, arg2);
-        }
+    class McpUtils {
         /**
-         * @description Asynchronous method implementing the Interface contract.
-         * @summary Throws an error with type casting chain.
+         * @description Dynamically imports a module file
+         * @summary Loads a JavaScript file and returns it as a CliModule, handling both ESM and CommonJS formats
          *
-         * @template T The type parameter used in the error casting chain
-         * @return {Promise<string>} A Promise that always rejects with an error
-         * @throws {Error} Always throws an error
+         * @param {string} path The file path to the module to load
+         * @return {Promise<McpModule>} A promise that resolves to the loaded CliModule
          */
-        async method() {
-            throw new Error("error");
+        static async loadFromFile(path) {
+            try {
+                return McpUtils.normalizeImport(import(path));
+            }
+            catch (e) {
+                throw new Error(`Failed to load from ${path}: ${e instanceof Error ? e.message : e}`);
+            }
         }
         /**
-         * @description Static method that throws an error.
-         * @summary A static utility method that always throws an error.
+         * @description Normalizes module imports to handle both ESM and CommonJS formats
+         * @summary Properly imports JavaScript files regardless of their module format by handling the ESM wrapper for CommonJS modules
          *
-         * @return {never} Never returns as it always throws an error
-         * @throws {Error} Always throws an error
-         * @static
+         * @template T The type of the imported module
+         * @param {Promise<T>} importPromise The promise returned by the dynamic import
+         * @return {Promise<T>} A promise that resolves to the normalized module
+         * @private
          */
-        static method() {
-            throw new Error("error");
+        static async normalizeImport(importPromise) {
+            // CommonJS's `module.exports` is wrapped as `default` in ESModule.
+            return importPromise.then((m) => (m.default || m));
         }
-    }
-
-    /**
-     * @class ChildClass
-     * @description This class extends the base Class and implements the ChildInterface.
-     * @summary Generic class extending Class and implementing ChildInterface with additional functionality.
-     * It provides a generic implementation with additional properties and methods.
-     *
-     * @param {unknown} arg1 - First argument of unknown type
-     * @param {string} arg2 - Second argument as string
-     *
-     * @template T - The generic type parameter
-     * @extends {Class}
-     * @implements {ChildInterface<T>}
-     */
-    class ChildClass extends Class {
-        constructor(arg1, arg2) {
-            super(arg1, arg2);
-            this.prop2 = arg1;
+        /**
+         * @description Retrieves and parses the package.json file
+         * @summary Reads the package.json file from the specified path and parses it into a JavaScript object
+         *
+         * @param {string} basePath The base path where the package.json file is located
+         * @return {Record<string, unknown>} The parsed package.json content as an object
+         * @private
+         */
+        static getPackage(basePath) {
+            try {
+                return JSON.parse(fs.readFileSync(path.join(basePath, "package.json"), "utf8"));
+            }
+            catch (e) {
+                throw new Error(`Unable to read version from ${basePath}: ${e}`);
+            }
         }
         /**
-         * @description This method overrides the base class method.
-         * @summary Asynchronous method that returns a string after a series of type assertions.
+         * @description Returns the version from package.json
+         * @summary Retrieves the version field from the package.json file at the specified path
          *
-         * @template V - The generic type parameter
-         * @return {Promise<string>} A Promise that resolves to a string
-         * @override
+         * @param {string} basePath The base path where the package.json file is located
+         * @return {string} The package version string
          */
-        async method() {
-            return "ok";
+        static packageVersion(basePath) {
+            return McpUtils.getPackage(basePath)["version"];
         }
         /**
-         * @description This method implements the method2 from ChildInterface.
-         * @summary Method that throws an error with a message that includes the input argument.
+         * @description Returns the name from package.json
+         * @summary Retrieves the name field from the package.json file at the specified path and extracts the package name without the scope
          *
-         * @param {T} arg1 - The input argument of generic type T
-         * @return {Promise<string>} A Promise that always rejects with an error
-         * @throws {Error} Always throws an error with a message including arg1
+         * @param {string} basePath The base path where the package.json file is located
+         * @return {string} The package name without the scope (e.g., "cli" from "@decaf-ts/cli")
          */
-        method2(arg1) {
-            throw new Error("error" + arg1);
+        static packageName(basePath) {
+            const name = McpUtils.getPackage(basePath)["name"].split("/");
+            return name[name.length - 1];
         }
     }
 
+    /* istanbul ignore file */
     /**
-     * @const Enum
-     * @name Enum
-     * @description This enum provides a set of predefined options that can be used throughout the application.
-     * @summary Enumeration of string options for consistent value representation.
-     * @type {enum}
-     * @readonly
-     *
-     * @memberOf module:ts-workspace.Namespace.ChildNamespace
-     */
-    exports.Enum = void 0;
-    (function (Enum) {
-        /** Represents the first option with value "something" */
-        Enum["OPTION1"] = "something";
-    })(exports.Enum || (exports.Enum = {}));
-
-    /**
-     * @function something
-     * @description This function is a generic method that extends the Class type.
-     * @summary Generic function that logs arguments and returns the context (this) of the function.
-     * It logs all provided arguments to the console and returns the context (this) of the function.
+     * @description Utility class to handle CLI functionality from all Decaf modules
+     * @summary This class provides a wrapper around Commander.js to handle CLI commands from different Decaf modules.
+     * It crawls the filesystem to find CLI modules, loads them, and registers their commands.
      *
-     * @template T - Type extending {@link Class}
-     * @template V - Type of the arguments
-     * @this {T}
-     * @param {...V} args - Variable number of arguments of type V
-     * @return {Type<T>} Returns the context (this) of the function
+     * @param {string} [basePath] The base path to look for modules in. Defaults to `./`
+     * @param {number} [crawlLevels] Number of folder levels to crawl to find modules from the basePath. Defaults to 4
      *
      * @example
-     * class MyClass extends Class {
-     *   myMethod() {
-     *     return something.call(this, 'arg1', 'arg2');
-     *   }
-     * }
+     * // Create a new CLI wrapper and run it with custom options
+     * const cli = new CliWrapper('./src', 2);
+     * cli.run(process.argv).then(() => {
+     *   console.log('CLI commands executed successfully');
+     * });
      *
-     * const instance = new MyClass();
-     * const result = instance.myMethod();
-     * // Logs: 'arg1', 'arg2'
-     * // result is the instance of MyClass
-     *
-     * @memberOf module:ts-workspace.Namespace.ChildNamespace
-     * @see {@link Class}
-     * @see {@link Type}
+     * @class McpWrapper
      */
-    function something(...args) {
-        console.log(...args);
-        return this;
+    class McpWrapper extends logging.LoggedClass {
+        constructor(basePath = "./", crawlLevels = 4) {
+            super();
+            this.basePath = basePath;
+            this.crawlLevels = crawlLevels;
+            this.modules = {};
+            this.rootPath = path.resolve(__dirname, "..");
+        }
+        /**
+         * @description Retrieves and initializes the Commander Command object
+         * @summary Lazy-loads the Command object, initializing it with the package name, description, and version
+         * @return {Command} The initialized Command object
+         * @private
+         */
+        get mcp() {
+            if (!this._mcp) {
+                this._mcp = new fastmcp.FastMCP({
+                    name: "decaf-ts MCP server",
+                    instructions: "",
+                    version: VERSION$1,
+                });
+            }
+            return this._mcp;
+        }
+        /**
+         * @description Loads and registers an mcp extension module from a file
+         * @summary Dynamically imports an mcp extension module from the specified file path, initializes it, and registers it in the modules collection
+         *
+         */
+        async load(server, filePath) {
+            const log = this.log.for(this.load);
+            let pkg, version, enrich;
+            try {
+                const res = await McpUtils.loadFromFile(filePath);
+                pkg = res.PACKAGE_NAME;
+                version = res.VERSION;
+                enrich = res.enrich;
+            }
+            catch (e) {
+                throw new Error(e.message || e);
+            }
+            try {
+                log.info(`Enriching mcp server with module ${pkg} v${version}`);
+                const result = enrich(server);
+                server = result instanceof Promise ? await result : result;
+            }
+            catch (e) {
+                throw new Error(`failed to enrich mcp with module ${pkg || "unnamed"} under ${filePath}: ${e instanceof Error ? e.message : e}`);
+            }
+            return {
+                mcp: server,
+                package: pkg,
+                version: version,
+            };
+        }
+        /**
+         * @description Finds and loads all CLI modules in the basePath
+         * @summary Uses the crawl method to find all CLI modules in the specified base path,
+         * then loads and registers each module as a subcommand
+         *
+         * @return {Promise<void>} A promise that resolves when all modules are loaded
+         *
+         * @private
+         * @mermaid
+         * sequenceDiagram
+         *   participant CliWrapper
+         *   participant Filesystem
+         *   participant Module
+         *
+         *   CliWrapper->>Filesystem: Join basePath with cwd
+         *   CliWrapper->>CliWrapper: crawl(basePath, crawlLevels)
+         *   CliWrapper-->>CliWrapper: modules[]
+         *   loop For each module
+         *     alt Not @decaf-ts/cli
+         *       CliWrapper->>CliWrapper: load(module, cwd)
+         *       CliWrapper-->>CliWrapper: name
+         *       CliWrapper->>CliWrapper: Check if command exists
+         *       alt Command doesn't exist
+         *         CliWrapper->>Command: command(name).addCommand(modules[name])
+         *       end
+         *     end
+         *   end
+         *   CliWrapper->>Console: Log loaded modules
+         */
+        async boot() {
+            const log = this.log.for(this.boot);
+            const basePath = path.resolve(this.rootPath, this.basePath);
+            const modules = this.crawl(basePath, this.crawlLevels);
+            let server = this.mcp;
+            for (const module of modules) {
+                if (module.includes("@decaf-ts/mcp")) {
+                    continue;
+                }
+                try {
+                    const res = await this.load(server, module);
+                    server = res.mcp;
+                }
+                catch (e) {
+                    log.error(`Failed to load MCP configs for ${module}: ${e}`);
+                }
+            }
+            console.log(`loaded modules:\n${Object.keys(this.modules)
+            .map((k) => `- ${k}`)
+            .join("\n")}`);
+            return server;
+        }
+        /**
+         * @description Recursively searches for CLI module files in the directory structure
+         * @summary Crawls the basePath up to the specified number of folder levels to find files named according to CLI_FILE_NAME
+         *
+         * @param {string} basePath The absolute base path to start searching in
+         * @param {number} [levels=2] The maximum number of directory levels to crawl
+         * @return {string[]} An array of file paths to CLI modules
+         *
+         * @private
+         */
+        crawl(basePath, levels = 2) {
+            if (levels <= 0)
+                return [];
+            return fs.readdirSync(basePath).reduce((accum, file) => {
+                file = path.join(basePath, file);
+                if (fs.statSync(file).isDirectory()) {
+                    accum.push(...this.crawl(file, levels - 1));
+                }
+                else if (file.match(new RegExp(`${MCP_FILE_NAME}.[cm]?js$`, "gm"))) {
+                    accum.push(file);
+                }
+                return accum;
+            }, []);
+        }
+        /**
+         * @description Executes the CLI with the provided arguments
+         * @summary Boots the CLI by loading all modules, then parses and executes the command specified in the arguments
+         *
+         * @param {string[]} [args=process.argv] Command line arguments to parse and execute
+         * @return {Promise<void>} A promise that resolves when the command execution is complete
+         *
+         * @mermaid
+         * sequenceDiagram
+         *   participant Client
+         *   participant CliWrapper
+         *   participant Command
+         *
+         *   Client->>CliWrapper: run(args)
+         *   CliWrapper->>CliWrapper: boot()
+         *   Note over CliWrapper: Loads all modules
+         *   CliWrapper->>Command: parseAsync(args)
+         *   Command-->>CliWrapper: result
+         *   CliWrapper-->>Client: result
+         */
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        async run(args = process.argv) {
+            const server = await this.boot();
+            await server.start({ transportType: "stdio" });
+        }
     }
 
-    /**
-     * @module ts-workspace
-     * @description This module serves as the main entry point for the ts-workspace library.
-     * @summary Aggregates and exports functionality from various submodules and utilities within the project.
-     *
-     * The module includes:
-     * 1. Utility functions and types from the "./utils" directory:
-     *    - These likely contain helper functions, common types, and shared functionality used throughout the project.
-     *    - May include operations for data manipulation, type checking, or other general-purpose utilities.
-     *
-     * 2. A namespace and related types from the "./namespace" directory:
-     *    - This could contain domain-specific code or a collection of related functionality.
-     *    - Might include interfaces, types, or classes that represent core concepts in the library.
-     *
-     * 3. A VERSION constant:
-     *    - Represents the current version of the module.
-     *    - Useful for version checking and compatibility purposes.
-     *
-     * This structure provides a clean and organized export of the module's functionality, allowing consumers
-     * to easily import and use specific parts of the library as needed.
-     */
-    /**
-     * @const VERSION
-     * @name VERSION
-     * @description Represents the current version of the ts-workspace module.
-     * @summary The actual version number is replaced during the build process.
-     * @type {string}
-     */
-    const VERSION = "0.0.2";
-
-    exports.ChildClass = ChildClass;
-    exports.Class = Class;
+    exports.MCP_FILE_NAME = MCP_FILE_NAME;
+    exports.McpUtils = McpUtils;
+    exports.McpWrapper = McpWrapper;
+    exports.PACKAGE_NAME = PACKAGE_NAME;
     exports.VERSION = VERSION;
-    exports.complexFunction = complexFunction;
-    exports.something = something;
+    exports.buildDocPrompts = buildDocPrompts;
+    exports.buildResourceTemplates = buildResourceTemplates;
+    exports.enrich = enrich;
+    exports.getWorkspaceRoot = getWorkspaceRoot;
+    exports.setWorkspaceRoot = setWorkspaceRoot;
+    exports.tools = tools;
 
 }));
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mcp-server.cjs","sources":["../src/utils.ts","../src/namespace/Class.ts","../src/namespace/children/ChildClass.ts","../src/namespace/children/Enum.ts","../src/namespace/children/function.ts","../src/index.ts"],"sourcesContent":["/**\n * @function complexFunction\n * @description This function takes an optional string argument and concatenates it with \"Hello World\".\n * @summary Concatenates \"Hello World\" with a given string. Despite its name, it's a simple string concatenation operation.\n *\n * @param {string} [arg1=\"default\"] - The string to append to \"Hello World\". If not provided, defaults to \"default\".\n * @return {string} The resulting concatenated string\n *\n * @example\n * // returns \"Hello Worlddefault\"\n * complexFunction();\n *\n * @example\n * // returns \"Hello World!\"\n * complexFunction(\"!\");\n *\n * @memberOf module:ts-workspace\n */\nexport function complexFunction(arg1: string = \"default\") {\n  return \"Hello World\" + arg1;\n}\n","import { Interface } from \"./Interface\";\n\n/**\n * @class Class\n * @description A class implementing the Interface contract.\n * @summary This class provides an implementation of the Interface contract with additional static functionality.\n * It manages an internal state through a private property and offers both instance and static methods.\n *\n * @param {unknown} arg1 - First argument of unknown type\n * @param {string} arg2 - Second argument as string\n *\n * @implements {Interface}\n *\n * @example\n * ```typescript\n * // Create a new instance\n * const instance = new Class('someValue', 'stringValue');\n *\n * // Using the generic method\n * await instance.method<string>()\n *   .catch(error => console.error(error));\n *\n * // Using the static method\n * Class.method();\n * ```\n *\n * @mermaid\n * sequenceDiagram\n *   participant Client\n *   participant Instance\n *   participant Static\n *\n *   Client->>Instance: new Class(arg1, arg2)\n *   activate Instance\n *   Instance-->>Client: class instance\n *   deactivate Instance\n *\n *   Client->>Instance: method<T>()\n *   activate Instance\n *   Instance-->>Client: Promise<string>\n *   deactivate Instance\n *\n *   Client->>Static: Class.method()\n *   activate Static\n *   Static-->>Client: void\n *   deactivate Static\n */\nexport class Class implements Interface {\n  /**\n   * @description Private property to store internal state.\n   * @summary An unknown type property used for internal state management.\n   * @private\n   * @type {unknown}\n   */\n  private prop!: unknown;\n\n  constructor(arg1: unknown, arg2: string) {\n    console.log(arg1, arg2);\n  }\n\n  /**\n   * @description Asynchronous method implementing the Interface contract.\n   * @summary Throws an error with type casting chain.\n   *\n   * @template T The type parameter used in the error casting chain\n   * @return {Promise<string>} A Promise that always rejects with an error\n   * @throws {Error} Always throws an error\n   */\n  async method<T>(): Promise<string> {\n    throw new Error(\"error\" as T as unknown as string);\n  }\n\n  /**\n   * @description Static method that throws an error.\n   * @summary A static utility method that always throws an error.\n   *\n   * @return {never} Never returns as it always throws an error\n   * @throws {Error} Always throws an error\n   * @static\n   */\n  static method() {\n    throw new Error(\"error\");\n  }\n}\n","import { Class } from \"../Class\";\nimport { ChildInterface } from \"./ChildInterface\";\n\n/**\n * @class ChildClass\n * @description This class extends the base Class and implements the ChildInterface.\n * @summary Generic class extending Class and implementing ChildInterface with additional functionality.\n * It provides a generic implementation with additional properties and methods.\n *\n * @param {unknown} arg1 - First argument of unknown type\n * @param {string} arg2 - Second argument as string\n *\n * @template T - The generic type parameter\n * @extends {Class}\n * @implements {ChildInterface<T>}\n */\nexport class ChildClass<T> extends Class implements ChildInterface<T> {\n  /**\n   * @description A private property of generic type T.\n   * @template {T}\n   * @summary Stores the first constructor argument for later use.\n   * @private\n   * @type {T}\n   */\n  private prop2?: T;\n\n  constructor(arg1: T, arg2: string) {\n    super(arg1, arg2);\n    this.prop2 = arg1;\n  }\n\n  /**\n   * @description This method overrides the base class method.\n   * @summary Asynchronous method that returns a string after a series of type assertions.\n   *\n   * @template V - The generic type parameter\n   * @return {Promise<string>} A Promise that resolves to a string\n   * @override\n   */\n  override async method<V>(): Promise<string> {\n    return \"ok\" as unknown as V as unknown as string;\n  }\n\n  /**\n   * @description This method implements the method2 from ChildInterface.\n   * @summary Method that throws an error with a message that includes the input argument.\n   *\n   * @param {T} arg1 - The input argument of generic type T\n   * @return {Promise<string>} A Promise that always rejects with an error\n   * @throws {Error} Always throws an error with a message including arg1\n   */\n  method2(arg1: T): Promise<string> {\n    throw new Error(\"error\" + arg1);\n  }\n}\n","/**\n * @const Enum\n * @name Enum\n * @description This enum provides a set of predefined options that can be used throughout the application.\n * @summary Enumeration of string options for consistent value representation.\n * @type {enum}\n * @readonly\n * \n * @memberOf module:ts-workspace.Namespace.ChildNamespace\n */\nexport enum Enum {\n  /** Represents the first option with value \"something\" */\n  OPTION1 = \"something\",\n}\n","import { Class } from \"../Class\";\nimport { Type } from \"../type\";\n\n/**\n * @function something\n * @description This function is a generic method that extends the Class type.\n * @summary Generic function that logs arguments and returns the context (this) of the function.\n * It logs all provided arguments to the console and returns the context (this) of the function.\n *\n * @template T - Type extending {@link Class}\n * @template V - Type of the arguments\n * @this {T}\n * @param {...V} args - Variable number of arguments of type V\n * @return {Type<T>} Returns the context (this) of the function\n *\n * @example\n * class MyClass extends Class {\n *   myMethod() {\n *     return something.call(this, 'arg1', 'arg2');\n *   }\n * }\n * \n * const instance = new MyClass();\n * const result = instance.myMethod();\n * // Logs: 'arg1', 'arg2'\n * // result is the instance of MyClass\n *\n * @memberOf module:ts-workspace.Namespace.ChildNamespace\n * @see {@link Class}\n * @see {@link Type}\n */\nexport function something<T extends Class, V>(this: T, ...args: V[]): Type<T> {\n  console.log(...args);\n  return this;\n}\n","/**\n * @module ts-workspace\n * @description This module serves as the main entry point for the ts-workspace library.\n * @summary Aggregates and exports functionality from various submodules and utilities within the project.\n * \n * The module includes:\n * 1. Utility functions and types from the \"./utils\" directory:\n *    - These likely contain helper functions, common types, and shared functionality used throughout the project.\n *    - May include operations for data manipulation, type checking, or other general-purpose utilities.\n * \n * 2. A namespace and related types from the \"./namespace\" directory:\n *    - This could contain domain-specific code or a collection of related functionality.\n *    - Might include interfaces, types, or classes that represent core concepts in the library.\n * \n * 3. A VERSION constant:\n *    - Represents the current version of the module.\n *    - Useful for version checking and compatibility purposes.\n * \n * This structure provides a clean and organized export of the module's functionality, allowing consumers\n * to easily import and use specific parts of the library as needed.\n */\n\nexport * from \"./utils\";\nexport * from \"./namespace\";\n\n/**\n * @const VERSION\n * @name VERSION\n * @description Represents the current version of the ts-workspace module.\n * @summary The actual version number is replaced during the build process.\n * @type {string}\n */\nexport const VERSION = \"##VERSION##\";\n"],"names":["Enum"],"mappings":";;;;;;IAAA;;;;;;;;;;;;;;;;;IAiBG;IACa,SAAA,eAAe,CAAC,IAAA,GAAe,SAAS,EAAA;QACtD,OAAO,aAAa,GAAG,IAAI;IAC7B;;IClBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA4CG;UACU,KAAK,CAAA;QAShB,WAAY,CAAA,IAAa,EAAE,IAAY,EAAA;IACrC,QAAA,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC;;IAGzB;;;;;;;IAOG;IACH,IAAA,MAAM,MAAM,GAAA;IACV,QAAA,MAAM,IAAI,KAAK,CAAC,OAAiC,CAAC;;IAGpD;;;;;;;IAOG;IACH,IAAA,OAAO,MAAM,GAAA;IACX,QAAA,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC;;IAE3B;;IChFD;;;;;;;;;;;;IAYG;IACG,MAAO,UAAc,SAAQ,KAAK,CAAA;QAUtC,WAAY,CAAA,IAAO,EAAE,IAAY,EAAA;IAC/B,QAAA,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC;IACjB,QAAA,IAAI,CAAC,KAAK,GAAG,IAAI;;IAGnB;;;;;;;IAOG;IACM,IAAA,MAAM,MAAM,GAAA;IACnB,QAAA,OAAO,IAAyC;;IAGlD;;;;;;;IAOG;IACH,IAAA,OAAO,CAAC,IAAO,EAAA;IACb,QAAA,MAAM,IAAI,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC;;IAElC;;ICtDD;;;;;;;;;IASG;AACSA;IAAZ,CAAA,UAAY,IAAI,EAAA;;IAEd,IAAA,IAAA,CAAA,SAAA,CAAA,GAAA,WAAqB;IACvB,CAAC,EAHWA,YAAI,KAAJA,YAAI,GAGf,EAAA,CAAA,CAAA;;ICVD;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2BG;IACa,SAAA,SAAS,CAA8B,GAAG,IAAS,EAAA;IACjE,IAAA,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;IACpB,IAAA,OAAO,IAAI;IACb;;IClCA;;;;;;;;;;;;;;;;;;;;IAoBG;IAKH;;;;;;IAMG;AACI,UAAM,OAAO,GAAG;;;;;;;;;;;;"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mcp-server.cjs","sources":["../src/metadata.ts","../src/modules/mcp/decorator-tools.ts","../src/modules/mcp/mcp-module.ts","../src/constants.ts","../src/utils.ts","../src/McpWrapper.ts"],"sourcesContent":["import { Metadata } from \"@decaf-ts/decoration\";\n\n/**\n * @const VERSION\n * @name VERSION\n * @description Represents the current version of the ts-workspace module.\n * @summary The actual version number is replaced during the build process.\n * @type {string}\n */\nexport const VERSION = \"##VERSION##\";\nexport const PACKAGE_NAME = \"##PACKAGE_NAME##\";\n\ntry {\n  Metadata.registerLibrary(PACKAGE_NAME, VERSION);\n} catch (error) {\n  if (error instanceof Error && error.message.includes(\"already\")) {\n    // Ignore duplicate registration during tests/bundling checks.\n  } else {\n    throw error;\n  }\n}\n","import fs from \"fs\";\nimport path from \"path\";\n\nexport type DecoratorSpec = {\n  name: string;\n  args?: unknown[];\n};\n\nexport type AttributeSpec = {\n  name: string;\n  type: string;\n  decorators?: DecoratorSpec[];\n};\n\nfunction escapeRegExp(value: string) {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\nfunction formatDecorator(spec: DecoratorSpec): string {\n  const args = (spec.args || []).map((arg) => JSON.stringify(arg)).join(\", \");\n  return `@${spec.name}(${args})`;\n}\n\nfunction ensureDirectory(filePath: string) {\n  fs.mkdirSync(path.dirname(filePath), { recursive: true });\n}\n\nfunction collectDecoratorNames(\n  classDecorators: DecoratorSpec[] | undefined,\n  properties: AttributeSpec[] | undefined\n) {\n  const names = new Set<string>();\n  names.add(\"model\");\n  for (const decorator of classDecorators || []) {\n    names.add(decorator.name);\n  }\n  for (const property of properties || []) {\n    for (const decorator of property.decorators || []) {\n      names.add(decorator.name);\n    }\n  }\n  return names;\n}\n\nfunction ensureImport(\n  content: string,\n  importsFrom: string,\n  decorators: Set<string>\n) {\n  /* istanbul ignore next */\n  if (!decorators.size) return content;\n  const importRegex = new RegExp(\n    `import\\\\s+\\\\{([^}]+)\\\\}\\\\s+from\\\\s+[\"']${escapeRegExp(importsFrom)}[\"'];`\n  );\n  const match = content.match(importRegex);\n  const sorted = Array.from(decorators).sort();\n\n  if (match) {\n    const existing = match[1]\n      .split(\",\")\n      .map((name) => name.trim())\n      .filter(Boolean);\n    const merged = Array.from(new Set([...existing, ...sorted])).sort();\n    return content.replace(\n      importRegex,\n      `import { ${merged.join(\", \")} } from \"${importsFrom}\";`\n    );\n  }\n\n  const importLine = `import { ${sorted.join(\", \")} } from \"${importsFrom}\";`;\n  return `${importLine}\\n\\n${content}`;\n}\n\nfunction addPropertyBlock(property: AttributeSpec) {\n  const decorators = (property.decorators || [])\n    .map(formatDecorator)\n    .join(\"\\n  \");\n  const decoratorBlock = decorators ? `  ${decorators}\\n` : \"\";\n  return `${decoratorBlock}  ${property.name}: ${property.type};`;\n}\n\nfunction removePropertyBlock(content: string, propertyName: string) {\n  const lines = content.split(/\\r?\\n/);\n  const result: string[] = [];\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i];\n    if (\n      line.trim().startsWith(`@`) &&\n      lines[i + 1]?.includes(`${propertyName}:`)\n    ) {\n      continue;\n    }\n    if (line.includes(`${propertyName}:`)) {\n      // skip this line and any trailing blank line\n      continue;\n    }\n    result.push(line);\n  }\n  return result.join(\"\\n\");\n}\n\nfunction insertDecorator(\n  content: string,\n  decorator: DecoratorSpec,\n  target: {\n    kind: \"class\" | \"property\";\n    name?: string;\n  }\n) {\n  const decoratorLine = formatDecorator(decorator);\n  if (target.kind === \"class\") {\n    const classRegex = /(export\\s+class\\s+[^\\s{]+\\s*\\{)/;\n    if (content.includes(decoratorLine)) return content;\n    return content.replace(classRegex, `${decoratorLine}\\n$1`);\n  }\n  if (!target.name) return content;\n  const propertyRegex = new RegExp(\n    `(^\\\\s*)(?:@.*\\\\n\\\\1)*${escapeRegExp(target.name)}:`,\n    \"m\"\n  );\n  const match = propertyRegex.exec(content);\n  if (!match) return content;\n  const indent = match[1] || \"  \";\n  if (content.includes(`${indent}${decoratorLine}`)) return content;\n  return (\n    content.slice(0, match.index) +\n    `${indent}${decoratorLine}\\n` +\n    content.slice(match.index)\n  );\n}\n\nfunction removeDecorator(\n  content: string,\n  decoratorName: string,\n  target: {\n    kind: \"class\" | \"property\";\n    name?: string;\n  }\n) {\n  const decoratorRegex = new RegExp(\n    `^\\\\s*@${escapeRegExp(decoratorName)}\\\\([^)]*\\\\)`,\n    \"m\"\n  );\n  if (target.kind === \"class\") {\n    return content.replace(decoratorRegex, \"\");\n  }\n  if (target.name) {\n    const pattern = new RegExp(\n      `(^\\\\s*@${escapeRegExp(decoratorName)}\\\\([^)]*\\\\)\\\\s*$\\\\n)(?=\\\\s*${escapeRegExp(target.name)}:)`,\n      \"m\"\n    );\n    return content.replace(pattern, \"\");\n  }\n  return content;\n}\n\nfunction writeIfChanged(filePath: string, content: string) {\n  ensureDirectory(filePath);\n  fs.writeFileSync(filePath, content);\n}\n\nexport const decoratorTools = {\n  createOrUpdateModelTool: {\n    name: \"create-or-update-model\",\n    description: \"Create or update a validation-ready model class\",\n    execute: async (args: {\n      filePath: string;\n      className: string;\n      classDecorators?: DecoratorSpec[];\n      properties: AttributeSpec[];\n      importsFrom: string;\n      overwrite?: boolean;\n    }) => {\n      if (!args.overwrite && fs.existsSync(args.filePath)) {\n        throw new Error(`File already exists at ${args.filePath}`);\n      }\n      const decorators = collectDecoratorNames(\n        args.classDecorators,\n        args.properties\n      );\n      let content = `@model()`;\n      for (const decorator of args.classDecorators || []) {\n        content += `\\n${formatDecorator(decorator)}`;\n      }\n      const properties = (args.properties || [])\n        .map(addPropertyBlock)\n        .join(\"\\n\\n\");\n      content += `\\nexport class ${args.className} {\\n${properties ? `${properties}\\n` : \"\"}}\\n`;\n      content = ensureImport(content, args.importsFrom, decorators);\n      writeIfChanged(args.filePath, content);\n      return { filePath: args.filePath };\n    },\n  },\n  addAttributeTool: {\n    name: \"add-attribute\",\n    description: \"Add a decorated attribute to an existing model\",\n    execute: async (args: {\n      filePath: string;\n      className: string;\n      attribute: AttributeSpec;\n      importsFrom: string;\n    }) => {\n      if (!fs.existsSync(args.filePath)) {\n        throw new Error(`Model file not found at ${args.filePath}`);\n      }\n      let content = fs.readFileSync(args.filePath, \"utf8\");\n      if (content.includes(`${args.attribute.name}:`)) {\n        return { filePath: args.filePath };\n      }\n      const decorators = collectDecoratorNames(undefined, [args.attribute]);\n      content = ensureImport(content, args.importsFrom, decorators);\n      const insertionPoint = content.lastIndexOf(\"}\");\n      const block = addPropertyBlock(args.attribute);\n      const before = content.slice(0, insertionPoint).replace(/\\s*$/, \"\");\n      const after = content.slice(insertionPoint);\n      const updated = `${before}\\n${block}\\n${after}`;\n      writeIfChanged(args.filePath, updated);\n      return { filePath: args.filePath };\n    },\n  },\n  removeAttributeTool: {\n    name: \"remove-attribute\",\n    description: \"Remove an attribute from a model class\",\n    execute: async (args: {\n      filePath: string;\n      className: string;\n      attributeName: string;\n    }) => {\n      if (!fs.existsSync(args.filePath)) return { filePath: args.filePath };\n      const content = fs.readFileSync(args.filePath, \"utf8\");\n      const updated = removePropertyBlock(content, args.attributeName);\n      writeIfChanged(args.filePath, updated);\n      return { filePath: args.filePath };\n    },\n  },\n  applyDecoratorTool: {\n    name: \"apply-decorator\",\n    description: \"Apply a decorator to a class or property\",\n    execute: async (args: {\n      filePath: string;\n      className: string;\n      target: { kind: \"class\" | \"property\"; name?: string };\n      decorator: DecoratorSpec;\n      importsFrom: string;\n    }) => {\n      if (!fs.existsSync(args.filePath)) {\n        throw new Error(`Model file not found at ${args.filePath}`);\n      }\n      let content = fs.readFileSync(args.filePath, \"utf8\");\n      const decorators = new Set<string>([args.decorator.name]);\n      content = ensureImport(content, args.importsFrom, decorators);\n      content = insertDecorator(content, args.decorator, args.target);\n      writeIfChanged(args.filePath, content);\n      return { filePath: args.filePath };\n    },\n  },\n  removeDecoratorTool: {\n    name: \"remove-decorator\",\n    description: \"Remove a decorator from a class or property\",\n    execute: async (args: {\n      filePath: string;\n      className: string;\n      target: { kind: \"class\" | \"property\"; name?: string };\n      decoratorName: string;\n    }) => {\n      if (!fs.existsSync(args.filePath)) return { filePath: args.filePath };\n      let content = fs.readFileSync(args.filePath, \"utf8\");\n      content = removeDecorator(content, args.decoratorName, args.target);\n      writeIfChanged(args.filePath, content);\n      return { filePath: args.filePath };\n    },\n  },\n  scaffoldValidatorTool: {\n    name: \"scaffold-validator\",\n    description: \"Scaffold a validator class and optional decorator\",\n    execute: async (args: {\n      validatorsDir: string;\n      decoratorDir?: string;\n      name: string;\n    }) => {\n      const classFile = path.join(args.validatorsDir, `${args.name}.ts`);\n      ensureDirectory(classFile);\n      const classContent = `export class ${args.name} {\\n  validate(value: unknown): boolean {\\n    return value !== undefined;\\n  }\\n}\\n`;\n      fs.writeFileSync(classFile, classContent);\n      let decoratorFile: string | undefined;\n      if (args.decoratorDir) {\n        decoratorFile = path.join(\n          args.decoratorDir,\n          `${args.name}Decorator.ts`\n        );\n        ensureDirectory(decoratorFile);\n        fs.writeFileSync(\n          decoratorFile,\n          `export function ${args.name}Decorator() {\\n  return () => void 0;\\n}\\n`\n        );\n      }\n      return { classFile, decoratorFile };\n    },\n  },\n  scaffoldSerializerTool: {\n    name: \"scaffold-serializer\",\n    description: \"Scaffold a serializer class and optional registry\",\n    execute: async (args: {\n      dir: string;\n      name: string;\n      registerDir?: string;\n      setDefault?: boolean;\n    }) => {\n      const classFile = path.join(args.dir, `${args.name}.ts`);\n      ensureDirectory(classFile);\n      fs.writeFileSync(\n        classFile,\n        `export class ${args.name} {\\n  serialize(value: unknown): string {\\n    return JSON.stringify(value);\\n  }\\n}\\n`\n      );\n      let registerFile: string | undefined;\n      if (args.registerDir) {\n        registerFile = path.join(args.registerDir, `${args.name}Register.ts`);\n        ensureDirectory(registerFile);\n        fs.writeFileSync(\n          registerFile,\n          `export function register${args.name}() {\\n  return ${args.setDefault ? \"'default'\" : \"'optional'\"};\\n}\\n`\n        );\n      }\n      return { classFile, registerFile };\n    },\n  },\n  scaffoldHashingTool: {\n    name: \"scaffold-hashing\",\n    description: \"Scaffold a hashing function and optional registry\",\n    execute: async (args: {\n      dir: string;\n      name: string;\n      registerDir?: string;\n      setDefault?: boolean;\n    }) => {\n      const functionFile = path.join(args.dir, `${args.name}.ts`);\n      ensureDirectory(functionFile);\n      fs.writeFileSync(\n        functionFile,\n        `export function ${args.name}(value: string): string {\\n  return value.split('').reverse().join('');\\n}\\n`\n      );\n      let registerFile: string | undefined;\n      if (args.registerDir) {\n        registerFile = path.join(args.registerDir, `${args.name}Register.ts`);\n        ensureDirectory(registerFile);\n        fs.writeFileSync(\n          registerFile,\n          `export function register${args.name}() {\\n  return ${args.setDefault ? \"'default'\" : \"'optional'\"};\\n}\\n`\n        );\n      }\n      return { functionFile, registerFile };\n    },\n  },\n} as const;\n\nexport type DecoratorTools = typeof decoratorTools;\n","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","/**\n * @description The filename that identifies Decaf CLI modules\n * @summary The standard filename for CLI module files where each library must export a single CliModule function\n *\n * @const MCP_FILE_NAME\n * @memberOf module:MCP\n */\nexport const MCP_FILE_NAME = \"mcp-module\";\n","/* istanbul ignore file */\nimport path from \"path\";\nimport fs from \"fs\";\nimport { McpModule } from \"./types\";\n\n/**\n * @description Utility class for CLI operations\n * @summary A static utility class that provides methods for loading modules, retrieving package information, and initializing CLI commands\n *\n * @example\n * // Initialize a Command object with package information\n * const command = new Command();\n * CLIUtils.initialize(command, './path/to/package');\n *\n * // Load a CLI module from a file\n * const module = await CLIUtils.loadFromFile('./path/to/cli-module.js');\n *\n * @class McpUtils\n */\nexport class McpUtils {\n  /**\n   * @description Dynamically imports a module file\n   * @summary Loads a JavaScript file and returns it as a CliModule, handling both ESM and CommonJS formats\n   *\n   * @param {string} path The file path to the module to load\n   * @return {Promise<McpModule>} A promise that resolves to the loaded CliModule\n   */\n  static async loadFromFile(path: string): Promise<McpModule> {\n    try {\n      return McpUtils.normalizeImport(import(path));\n    } catch (e: unknown) {\n      throw new Error(\n        `Failed to load from ${path}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n  }\n\n  /**\n   * @description Normalizes module imports to handle both ESM and CommonJS formats\n   * @summary Properly imports JavaScript files regardless of their module format by handling the ESM wrapper for CommonJS modules\n   *\n   * @template T The type of the imported module\n   * @param {Promise<T>} importPromise The promise returned by the dynamic import\n   * @return {Promise<T>} A promise that resolves to the normalized module\n   * @private\n   */\n  static async normalizeImport<T>(importPromise: Promise<T>): Promise<T> {\n    // CommonJS's `module.exports` is wrapped as `default` in ESModule.\n    return importPromise.then(\n      (m: unknown) => ((m as { default: T }).default || m) as T\n    );\n  }\n\n  /**\n   * @description Retrieves and parses the package.json file\n   * @summary Reads the package.json file from the specified path and parses it into a JavaScript object\n   *\n   * @param {string} basePath The base path where the package.json file is located\n   * @return {Record<string, unknown>} The parsed package.json content as an object\n   * @private\n   */\n  private static getPackage(basePath: string): Record<string, unknown> {\n    try {\n      return JSON.parse(\n        fs.readFileSync(path.join(basePath, \"package.json\"), \"utf8\")\n      );\n    } catch (e: unknown) {\n      throw new Error(`Unable to read version from ${basePath}: ${e}`);\n    }\n  }\n\n  /**\n   * @description Returns the version from package.json\n   * @summary Retrieves the version field from the package.json file at the specified path\n   *\n   * @param {string} basePath The base path where the package.json file is located\n   * @return {string} The package version string\n   */\n  static packageVersion(basePath: string): string {\n    return McpUtils.getPackage(basePath)[\"version\"] as string;\n  }\n\n  /**\n   * @description Returns the name from package.json\n   * @summary Retrieves the name field from the package.json file at the specified path and extracts the package name without the scope\n   *\n   * @param {string} basePath The base path where the package.json file is located\n   * @return {string} The package name without the scope (e.g., \"cli\" from \"@decaf-ts/cli\")\n   */\n  static packageName(basePath: string): string {\n    const name = (McpUtils.getPackage(basePath)[\"name\"] as string).split(\"/\");\n    return name[name.length - 1];\n  }\n}\n","/* istanbul ignore file */\nimport fs from \"fs\";\nimport path from \"path\";\nimport { MCP_FILE_NAME } from \"./constants\";\nimport { McpUtils } from \"./utils\";\nimport { FastMCP } from \"fastmcp\";\nimport { LoggedClass } from \"@decaf-ts/logging\";\nimport { VERSION } from \"./metadata\";\n\n/**\n * @description Utility class to handle CLI functionality from all Decaf modules\n * @summary This class provides a wrapper around Commander.js to handle CLI commands from different Decaf modules.\n * It crawls the filesystem to find CLI modules, loads them, and registers their commands.\n *\n * @param {string} [basePath] The base path to look for modules in. Defaults to `./`\n * @param {number} [crawlLevels] Number of folder levels to crawl to find modules from the basePath. Defaults to 4\n *\n * @example\n * // Create a new CLI wrapper and run it with custom options\n * const cli = new CliWrapper('./src', 2);\n * cli.run(process.argv).then(() => {\n *   console.log('CLI commands executed successfully');\n * });\n *\n * @class McpWrapper\n */\nexport class McpWrapper extends LoggedClass {\n  private _mcp?: FastMCP;\n  private modules: Record<string, string> = {};\n  private readonly rootPath: string;\n\n  constructor(\n    private basePath: string = \"./\",\n    private crawlLevels = 4\n  ) {\n    super();\n    this.rootPath = path.resolve(__dirname, \"..\");\n  }\n\n  /**\n   * @description Retrieves and initializes the Commander Command object\n   * @summary Lazy-loads the Command object, initializing it with the package name, description, and version\n   * @return {Command} The initialized Command object\n   * @private\n   */\n  private get mcp() {\n    if (!this._mcp) {\n      this._mcp = new FastMCP({\n        name: \"decaf-ts MCP server\",\n        instructions: \"\",\n        version: VERSION as any,\n      });\n    }\n    return this._mcp;\n  }\n\n  /**\n   * @description Loads and registers an mcp extension module from a file\n   * @summary Dynamically imports an mcp extension module from the specified file path, initializes it, and registers it in the modules collection\n   *\n   */\n  private async load(\n    server: FastMCP,\n    filePath: string\n  ): Promise<{ mcp: FastMCP; package: string; version: string }> {\n    const log = this.log.for(this.load);\n\n    let pkg: string, version: string, enrich: any;\n    try {\n      const res = await McpUtils.loadFromFile(filePath);\n      pkg = res.PACKAGE_NAME;\n      version = res.VERSION;\n      enrich = res.enrich;\n    } catch (e: unknown) {\n      throw new Error((e as any).message || (e as any));\n    }\n    try {\n      log.info(`Enriching mcp server with module ${pkg} v${version}`);\n      const result = enrich(server);\n      server = result instanceof Promise ? await result : result;\n    } catch (e: unknown) {\n      throw new Error(\n        `failed to enrich mcp with module ${pkg || \"unnamed\"} under ${filePath}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n    return {\n      mcp: server,\n      package: pkg,\n      version: version,\n    };\n  }\n\n  /**\n   * @description Finds and loads all CLI modules in the basePath\n   * @summary Uses the crawl method to find all CLI modules in the specified base path,\n   * then loads and registers each module as a subcommand\n   *\n   * @return {Promise<void>} A promise that resolves when all modules are loaded\n   *\n   * @private\n   * @mermaid\n   * sequenceDiagram\n   *   participant CliWrapper\n   *   participant Filesystem\n   *   participant Module\n   *\n   *   CliWrapper->>Filesystem: Join basePath with cwd\n   *   CliWrapper->>CliWrapper: crawl(basePath, crawlLevels)\n   *   CliWrapper-->>CliWrapper: modules[]\n   *   loop For each module\n   *     alt Not @decaf-ts/cli\n   *       CliWrapper->>CliWrapper: load(module, cwd)\n   *       CliWrapper-->>CliWrapper: name\n   *       CliWrapper->>CliWrapper: Check if command exists\n   *       alt Command doesn't exist\n   *         CliWrapper->>Command: command(name).addCommand(modules[name])\n   *       end\n   *     end\n   *   end\n   *   CliWrapper->>Console: Log loaded modules\n   */\n  private async boot() {\n    const log = this.log.for(this.boot);\n\n    const basePath = path.resolve(this.rootPath, this.basePath);\n    const modules = this.crawl(basePath, this.crawlLevels);\n    let server = this.mcp;\n    for (const module of modules) {\n      if (module.includes(\"@decaf-ts/mcp\")) {\n        continue;\n      }\n      try {\n        const res = await this.load(server, module);\n        server = res.mcp;\n      } catch (e: unknown) {\n        log.error(`Failed to load MCP configs for ${module}: ${e}`);\n      }\n    }\n    console.log(\n      `loaded modules:\\n${Object.keys(this.modules)\n        .map((k) => `- ${k}`)\n        .join(\"\\n\")}`\n    );\n    return server;\n  }\n\n  /**\n   * @description Recursively searches for CLI module files in the directory structure\n   * @summary Crawls the basePath up to the specified number of folder levels to find files named according to CLI_FILE_NAME\n   *\n   * @param {string} basePath The absolute base path to start searching in\n   * @param {number} [levels=2] The maximum number of directory levels to crawl\n   * @return {string[]} An array of file paths to CLI modules\n   *\n   * @private\n   */\n  private crawl(basePath: string, levels: number = 2) {\n    if (levels <= 0) return [];\n    return fs.readdirSync(basePath).reduce((accum: string[], file) => {\n      file = path.join(basePath, file);\n      if (fs.statSync(file).isDirectory()) {\n        accum.push(...this.crawl(file, levels - 1));\n      } else if (file.match(new RegExp(`${MCP_FILE_NAME}.[cm]?js$`, \"gm\"))) {\n        accum.push(file);\n      }\n      return accum;\n    }, []);\n  }\n\n  /**\n   * @description Executes the CLI with the provided arguments\n   * @summary Boots the CLI by loading all modules, then parses and executes the command specified in the arguments\n   *\n   * @param {string[]} [args=process.argv] Command line arguments to parse and execute\n   * @return {Promise<void>} A promise that resolves when the command execution is complete\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant Client\n   *   participant CliWrapper\n   *   participant Command\n   *\n   *   Client->>CliWrapper: run(args)\n   *   CliWrapper->>CliWrapper: boot()\n   *   Note over CliWrapper: Loads all modules\n   *   CliWrapper->>Command: parseAsync(args)\n   *   Command-->>CliWrapper: result\n   *   CliWrapper-->>Client: result\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async run(args: string[] = process.argv) {\n    const server = await this.boot();\n    await server.start({ transportType: \"stdio\" });\n  }\n}\n"],"names":["VERSION","PACKAGE_NAME","Metadata","z","applyPatch","createTwoFilesPatch","PKG","V","LoggedClass","FastMCP"],"mappings":"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"}