@decaf-ts/mcp-server 0.0.3 → 0.2.0

package/dist/mcp-server.cjs

@@ -1,28 +1,992 @@
 (function (global, factory) {
-    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';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('fs'), require('path'), require('diff'), require('zod'), require('child_process'), require('@decaf-ts/decoration'), require('url'), require('node:fs'), require('node:path'), require('fastmcp'), require('@decaf-ts/logging')) :
+    typeof define === 'function' && define.amd ? define(['exports', 'fs', 'path', 'diff', 'zod', 'child_process', '@decaf-ts/decoration', 'url', 'node:fs', 'node:path', '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.child_process, global.decoration, global.url, global.fs$1, global.path$1, global.fastmcp, global.logging));
+})(this, (function (exports, fs, path, diff, zod, child_process, decoration, url, fs$1, path$1, fastmcp, logging) { 'use strict';
 
     /**
-     * @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}
+     * @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
+     *
+     * @const MCP_FILE_NAME
+     * @memberOf module:MCP
      */
-    const VERSION$1 = "0.0.2";
-    const PACKAGE_NAME$1 = "##PACKAGE_NAME##";
-    try {
-        decoration.Metadata.registerLibrary(PACKAGE_NAME$1, VERSION$1);
+    const MCP_FILE_NAME = "mcp-module";
+    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.",
+        },
+    ];
+
+    let workspaceRoot = initializeWorkspaceRoot();
+    let userErrorCtor;
+    class WorkspaceError extends Error {
+        constructor(message) {
+            super(message);
+            this.name = "WorkspaceError";
+        }
+    }
+    function initializeWorkspaceRoot() {
+        const configured = process.env[WORKSPACE_ROOT_ENV];
+        if (configured && configured.trim().length > 0) {
+            return path.resolve(configured.trim());
+        }
+        return process.cwd();
+    }
+    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);
+    }
+    function setWorkspaceRoot(root) {
+        workspaceRoot = path.resolve(root);
+    }
+    function getWorkspaceRoot() {
+        return workspaceRoot;
+    }
+    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 __resetWorkspaceRoot(root) {
+        setWorkspaceRoot(root);
+    }
+
+    const prompts$3 = [];
+
+    const resources$3 = [
+        {
+            "id": "decoration.repo",
+            "name": "decoration repository",
+            "description": "Source repository",
+            "uri": "file:///home/tvenceslau/local-workspace/decaf-ts/mcp-server/src/modules/decoration",
+            "absolutePath": "/home/tvenceslau/local-workspace/decaf-ts/mcp-server/src/modules/decoration"
+        }
+    ];
+
+    const templates$2 = [
+        {
+            "name": "readme-template",
+            "description": "README as guidance",
+            "uriTemplate": "file:///home/tvenceslau/local-workspace/decaf-ts/mcp-server/src/modules/decoration/README.md",
+            "mimeType": "text/markdown"
+        }
+    ];
+
+    const analyzeRepoSchema = zod.z
+        .object({
+        repoPath: zod.z
+            .string()
+            .min(1, "repoPath is required")
+            .describe("Relative or absolute path to the target repository inside this monorepo, e.g. './decoration'."),
+        includeTests: zod.z
+            .boolean()
+            .default(true)
+            .describe("If true, analyze the tests directory (if present) to derive expected behaviors."),
+        includeDocs: zod.z
+            .boolean()
+            .default(true)
+            .describe("If true, analyze README.md and docs directories to extract documented features."),
+    })
+        .strict()
+        .describe("Analyze a local repository (e.g. ./decoration) to extract APIs, features, tests, and documentation cues.");
+    const enumerateCapabilitiesSchema = zod.z
+        .object({
+        repoPath: zod.z
+            .string()
+            .min(1, "repoPath is required")
+            .describe("Relative or absolute path to the target repository to enumerate developer-facing capabilities."),
+    })
+        .strict()
+        .describe("Enumerate the complete set of capabilities a developer is expected to use from the given repository.");
+    const planFeatureSchema = zod.z
+        .object({
+        feature: zod.z
+            .string()
+            .min(5, "feature must describe the goal clearly")
+            .describe("Natural-language description of a developer's requested feature or task to implement using the repository and available MCP tools."),
+        repoPath: zod.z
+            .string()
+            .default("./decoration")
+            .describe("Target repository path providing the library to use, e.g. './decoration'."),
+    })
+        .strict()
+        .describe("Plan which MCP tools to use and in what sequence to implement a requested feature using the repository.");
+    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();
+    const OBJECT_TYPES = [
+        "module",
+        "file",
+        "class",
+        "function",
+        "interface",
+        "decorator",
+        "constant",
+    ];
+    const documentObjectSchema = zod.z
+        .object({
+        basePath: zod.z.string().min(1, "basePath is required"),
+        objectType: zod.z.enum(OBJECT_TYPES),
+        targetFile: zod.z.string().optional(),
+        includeContent: zod.z.boolean().default(false),
+    })
+        .strict();
+    const coverageTaskSchema = zod.z
+        .object({
+        basePath: zod.z.string().min(1, "basePath is required"),
+        coverage: zod.z
+            .number()
+            .min(0)
+            .max(100)
+            .default(90)
+            .describe("Target coverage percentage"),
+        dryRun: zod.z.boolean().default(false),
+    })
+        .strict();
+    const readmeImprovementSchema = zod.z
+        .object({
+        basePath: zod.z.string().min(1, "basePath is required"),
+        includeExamples: zod.z.boolean().default(true),
+    })
+        .strict();
+
+    function readFileSafe(filePath, encoding = "utf8") {
+        try {
+            return fs.readFileSync(filePath, { encoding });
+        }
+        catch {
+            return undefined;
+        }
+    }
+    function listFilesRecursive(root, matcher) {
+        const out = [];
+        const stack = [root];
+        while (stack.length) {
+            const cur = stack.pop();
+            const stat = fs.statSync(cur);
+            if (stat.isDirectory()) {
+                for (const f of fs.readdirSync(cur))
+                    stack.push(path.join(cur, f));
+            }
+            else if (!matcher || matcher(cur)) {
+                out.push(cur);
+            }
+        }
+        return out.sort();
+    }
+    function deriveCapabilities(analysis) {
+        const cap = new Set();
+        // heuristics: if decorators like Decoration, flavouredAs, extend, override appear, add capabilities
+        const allDecs = new Set();
+        for (const k of Object.keys(analysis.api)) {
+            for (const d of analysis.api[k].decorators)
+                allDecs.add(d);
+            for (const e of analysis.api[k].exports)
+                if (/Decoration|decorate|Builder|Flavour/i.test(e))
+                    cap.add("use-decoration-api");
+        }
+        if ([...allDecs].some((d) => /override|extend/i.test(d)))
+            cap.add("override-and-extend-decorations");
+        if (Object.keys(analysis.tests).length > 0)
+            cap.add("validate-with-tests");
+        if (analysis.readme)
+            cap.add("follow-readme-guides");
+        return [...cap].sort();
+    }
+
+    // Analysis helpers (minimal yet effective, text-based to avoid heavy AST deps)
+    function isSourceFile(p) {
+        return /\.(ts|tsx|js|jsx)$/.test(p) && !p.endsWith(".d.ts");
+    }
+    function isTestFile(p) {
+        return /(\.test\.|\.spec\.)/.test(p);
+    }
+    function extractExports(fileContent) {
+        const names = new Set();
+        const exportRe = /(export\s+(?:default\s+)?(?:class|function|const|let|var|interface|type|enum)\s+)([A-Za-z0-9_]+)/g;
+        const namedRe = /export\s*\{([^}]+)\}/g;
+        let m;
+        while ((m = exportRe.exec(fileContent)))
+            names.add(m[2]);
+        while ((m = namedRe.exec(fileContent))) {
+            m[1]
+                .split(",")
+                .map((s) => s.trim().split(" as ")[0].trim())
+                .forEach((n) => {
+                if (n)
+                    names.add(n);
+            });
+        }
+        return [...names].sort();
+    }
+    function extractDecorators(fileContent) {
+        const decs = new Set();
+        const decRe = /@([A-Za-z_][A-Za-z0-9_]*)/g;
+        let m;
+        while ((m = decRe.exec(fileContent)))
+            decs.add(m[1]);
+        return [...decs].sort();
+    }
+    function summarizeReadme(readme) {
+        if (!readme)
+            return undefined;
+        const lines = readme.split(/\r?\n/).filter(Boolean);
+        const title = lines.find((l) => /^#\s+/.test(l))?.replace(/^#\s+/, "") || "README";
+        const bullets = lines.filter((l) => /^[-*]\s+/.test(l)).slice(0, 20);
+        return { title, bullets };
+    }
+    function analyzeRepo(root) {
+        const src = path.join(root, "src");
+        const testDir = path.join(root, "tests");
+        const readmePath = path.join(root, "README.md");
+        const readme = readFileSafe(readmePath);
+        const files = fs.existsSync(src) ? listFilesRecursive(src, isSourceFile) : [];
+        const testFiles = fs.existsSync(testDir)
+            ? listFilesRecursive(testDir, (f) => isSourceFile(f) && isTestFile(f))
+            : [];
+        const api = {};
+        for (const f of files) {
+            const content = readFileSafe(f) || "";
+            api[path.relative(root, f)] = {
+                exports: extractExports(content),
+                decorators: extractDecorators(content),
+            };
+        }
+        const tests = {};
+        for (const f of testFiles) {
+            const content = readFileSafe(f) || "";
+            const mentions = Array.from(new Set([...extractExports(content), ...extractDecorators(content)])).sort();
+            tests[path.relative(root, f)] = { mentions };
+        }
+        return { files, testFiles, api, tests, readme: summarizeReadme(readme) };
+    }
+
+    function buildAnalyzeRepositoryTool() {
+        return {
+            name: "analyze-repository",
+            description: "Analyze a local repository's source, tests, and docs to extract exported APIs, decorators, and test mentions.",
+            parameters: analyzeRepoSchema,
+            execute: async (input) => {
+                let repoRoot = path.resolve(process.cwd(), input.repoPath);
+                if (!fs.existsSync(repoRoot)) {
+                    // try resolving from monorepo root (parent of current cwd)
+                    const alt = path.resolve(process.cwd(), "..", input.repoPath);
+                    if (fs.existsSync(alt))
+                        repoRoot = alt;
+                }
+                if (!fs.existsSync(repoRoot)) {
+                    // if input was absolute and still not found, try ../<basename>
+                    const alt2 = path.resolve(process.cwd(), "..", path.basename(input.repoPath));
+                    if (fs.existsSync(alt2))
+                        repoRoot = alt2;
+                }
+                if (!fs.existsSync(repoRoot))
+                    throw new Error(`Repository not found at ${repoRoot}`);
+                const result = analyzeRepo(repoRoot);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            },
+        };
+    }
+    function buildEnumerateCapabilitiesTool() {
+        return {
+            name: "enumerate-capabilities",
+            description: "Enumerate developer-facing capabilities of the given repository, inferred from code, tests, and docs.",
+            parameters: enumerateCapabilitiesSchema,
+            execute: async (input) => {
+                let repoRoot = path.resolve(process.cwd(), input.repoPath);
+                if (!fs.existsSync(repoRoot)) {
+                    const alt = path.resolve(process.cwd(), "..", input.repoPath);
+                    if (fs.existsSync(alt))
+                        repoRoot = alt;
+                }
+                if (!fs.existsSync(repoRoot)) {
+                    const alt2 = path.resolve(process.cwd(), "..", path.basename(input.repoPath));
+                    if (fs.existsSync(alt2))
+                        repoRoot = alt2;
+                }
+                if (!fs.existsSync(repoRoot))
+                    throw new Error(`Repository not found at ${repoRoot}`);
+                const analysis = analyzeRepo(repoRoot);
+                const capabilities = deriveCapabilities(analysis);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                capabilities,
+                                analysisSummary: {
+                                    files: analysis.files.length,
+                                    testFiles: analysis.testFiles.length,
+                                    readme: analysis.readme?.title,
+                                },
+                            }, null, 2),
+                        },
+                    ],
+                };
+            },
+        };
+    }
+    function buildPlanFeatureTool() {
+        return {
+            name: "plan-feature-implementation",
+            description: "Given a feature request, select appropriate MCP tools (including existing and new ones) and produce an execution plan.",
+            parameters: planFeatureSchema,
+            execute: async (input) => {
+                const steps = [];
+                let i = 1;
+                steps.push({
+                    step: i++,
+                    action: "Analyze repository to enumerate APIs and decorators",
+                    tool: "analyze-repository",
+                    arguments: { repoPath: input.repoPath },
+                    rationale: "Understand available building blocks.",
+                });
+                steps.push({
+                    step: i++,
+                    action: "List capabilities expected for developers",
+                    tool: "enumerate-capabilities",
+                    arguments: { repoPath: input.repoPath },
+                    rationale: "Align the plan with supported capabilities.",
+                });
+                // Suggest existing generic tools from mcp-module
+                steps.push({
+                    step: i++,
+                    action: "Select documentation prompt and gather relevant source file(s)",
+                    tool: "document-code",
+                    arguments: { filePath: "<target-file>" },
+                    rationale: "Provide context and instructions for changes.",
+                });
+                steps.push({
+                    step: i++,
+                    action: "Apply code changes using unified diff patch",
+                    tool: "apply-code-change",
+                    arguments: {
+                        filePath: "<target-file>",
+                        patch: "<unified-diff>",
+                        dryRun: true,
+                    },
+                    rationale: "Validate changes safely before committing.",
+                });
+                steps.push({
+                    step: i++,
+                    action: "Commit code changes",
+                    tool: "apply-code-change",
+                    arguments: {
+                        filePath: "<target-file>",
+                        patch: "<unified-diff>",
+                        dryRun: false,
+                    },
+                    rationale: "Persist the update.",
+                });
+                // If decoration-related terms present, suggest decorator tools
+                if (/decorat|flavour|override|extend|builder/i.test(input.feature)) {
+                    steps.unshift({
+                        step: 0,
+                        action: "Use decorator tooling to insert/remove/modify decorators",
+                        tool: "decorator-tools",
+                        arguments: { action: "help" },
+                        rationale: "Leverage specialized utilities for decoration patterns.",
+                    });
+                    steps.forEach((s, idx) => (s.step = idx + 1));
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                plan: steps,
+                                notes: "Replace placeholder arguments like <target-file> and <unified-diff> based on the analysis output.",
+                            }, null, 2),
+                        },
+                    ],
+                };
+            },
+        };
+    }
+    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 analyticTools = [
+        buildAnalyzeRepositoryTool(),
+        buildEnumerateCapabilitiesTool(),
+        buildPlanFeatureTool(),
+    ];
+    const toolList$1 = [
+        ...analyticTools,
+        documentCodeTool,
+        applyCodeChangeTool,
+    ];
+
+    const tools$3 = [
+        { id: 'decoration.analyze', title: 'Analyze decoration', description: 'Analyze the target repository', tool: buildAnalyzeRepositoryTool() },
+        { id: 'decoration.enumerate', title: 'Enumerate capabilities for decoration', description: 'Enumerate capabilities', tool: buildEnumerateCapabilitiesTool() },
+        { id: 'decoration.plan', title: 'Plan features for decoration', description: 'Plan feature implementation', tool: buildPlanFeatureTool() },
+    ];
+
+    const modulePackage$2 = { name: 'decoration', prompts: prompts$3, resources: resources$3, templates: templates$2, tools: tools$3 };
+
+    const prompts$2 = [
+        {
+            id: "mcp.prompt.module-catalog",
+            title: "Decaf MCP Module Catalog",
+            description: "Summarizes the modules contributing prompts/resources/templates/tools to FASTMCP.",
+            load: async () => "Use the module catalog tool to enumerate available module assets before fulfilling assistant requests.",
+        },
+    ];
+
+    const resources$2 = [
+        {
+            id: "mcp.resource.registry-overview",
+            title: "Module Registry Overview",
+            description: "Explains how the ModuleRegistry aggregates module exports into FASTMCP catalogs.",
+            uri: "decaf://mcp/module-registry",
+            mimeType: "text/markdown",
+            load: async () => ({
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            "# Module Registry",
+                            "",
+                            "The Decaf MCP server aggregates prompts, resources, templates, and tools from every module under src/modules.",
+                            "Validators ensure each module contains the canonical folder layout before the registry loads it.",
+                        ].join("\n"),
+                        mimeType: "text/markdown",
+                    },
+                ],
+            }),
+        },
+    ];
+
+    const templates$1 = [
+        {
+            id: "mcp.template.module-readme",
+            title: "Module README Template",
+            description: "Guides maintainers through documenting a new MCP-aware module.",
+            content: `# {{moduleName}} Module
+
+## Purpose
+Describe why this module exists and how assistants should use it.
+
+## Assets
+- Prompts: {{promptSummary}}
+- Resources: {{resourceSummary}}
+- Templates: {{templateSummary}}
+- Tools: {{toolSummary}}
+
+## Validation
+Explain what needs to happen when this module changes (tests, docs, etc.).`,
+            placeholders: [
+                "moduleName",
+                "promptSummary",
+                "resourceSummary",
+                "templateSummary",
+                "toolSummary",
+            ],
+        },
+    ];
+
+    const describeModulesTool = {
+        name: "describe-modules",
+        description: "Summarize the purpose of Decaf MCP modules for assistant operators.",
+        // Minimal execute implementation to return a text result
+        execute: async () => "Modules contribute prompts, resources, templates, and tools that the registry exposes to FASTMCP clients.",
+    };
+    const tools$2 = [
+        {
+            id: "mcp.tool.describe-modules",
+            title: "Describe MCP Modules",
+            description: "Explains how module exports feed into the FASTMCP server.",
+            tool: describeModulesTool,
+        },
+    ];
+
+    const modulePackage$1 = {
+        name: "mcp",
+        prompts: prompts$2,
+        resources: resources$2,
+        templates: templates$1,
+        tools: tools$2,
+    };
+
+    const prompts$1 = [
+        {
+            id: "_template.readme",
+            title: "Template README",
+            description: "A README prompt for module template",
+            load: () => "Template prompt content",
+        },
+    ];
+
+    const resources$1 = [
+        {
+            id: "_template.repo",
+            name: "template repo",
+            description: "Template resource",
+            uri: "file:///tmp/template",
+        },
+    ];
+
+    const templates = [
+        {
+            id: "_template.readme",
+            name: "template-readme",
+            description: "README guidance",
+            uriTemplate: "file:///tmp/template/README.md",
+            mimeType: "text/markdown",
+        },
+    ];
+
+    const placeholderTool = {
+        name: "_template.tool",
+        description: "A placeholder tool",
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        execute: async (_input, _context) => "ok",
+    };
+    const tools$1 = [
+        {
+            id: "_template.tool",
+            title: "template tool",
+            description: "A placeholder tool",
+            tool: placeholderTool,
+        },
+    ];
+
+    const modulePackage = {
+        name: "_template",
+        prompts: prompts$1,
+        resources: resources$1,
+        templates,
+        tools: tools$1,
+    };
+
+    // modulePackage objects may be declared with readonly arrays (as const). Cast to the mutable type expected by runtime APIs.
+    const modulePackages = [
+        modulePackage$2,
+        modulePackage$1,
+        modulePackage,
+    ];
+
+    class ModuleRegistry {
+        // Defensive default: modulePackages may be undefined during circular imports
+        constructor(packages = Array.isArray(modulePackages)
+            ? modulePackages
+            : []) {
+            this.packages = packages;
+        }
+        listPackages() {
+            return this.packages;
+        }
+        listPrompts() {
+            return this.collectAssets("prompts");
+        }
+        listResources() {
+            return this.collectAssets("resources");
+        }
+        listTemplates() {
+            return this.collectAssets("templates");
+        }
+        listTools() {
+            return this.collectAssets("tools");
+        }
+        collectAssets(key) {
+            const seen = new Map();
+            const aggregated = [];
+            for (const pkg of this.packages) {
+                if (pkg.status === "disabled")
+                    continue;
+                for (const asset of pkg[key]) {
+                    // asset.name is not guaranteed on all asset types; use type-safe fallback
+                    const maybeName = asset.name;
+                    const assetKey = (asset && (asset.id ?? maybeName)) || JSON.stringify(asset);
+                    if (seen.has(assetKey)) {
+                        const conflict = seen.get(assetKey);
+                        throw new Error(`Duplicate ${key} id '${assetKey}' from modules ${conflict} and ${pkg.name}`);
+                    }
+                    seen.set(assetKey, pkg.name);
+                    aggregated.push({ ...asset, provenance: pkg.name });
+                }
+            }
+            return aggregated;
+        }
     }
-    catch (error) {
-        if (error instanceof Error && error.message.includes("already")) ;
-        else {
-            throw error;
+    const moduleRegistry = new ModuleRegistry();
+
+    const prompts = [];
+    const OBJECT_PROMPT_DEPENDENCIES = {
+        module: ["doc", "module"],
+        file: ["doc", "file"],
+        class: ["doc", "class"],
+        function: ["doc", "function"],
+        interface: ["doc", "interface"],
+        decorator: ["doc", "decorator"],
+        constant: ["doc", "constant"],
+        "bulk-docs": ["bulk-docs"],
+        "bulk-tests": ["bulk-tests"],
+        "update-readme": ["update-readme"],
+        "repo-setup": ["repo-setup"],
+        "release-notes": ["release-notes"],
+        "mcp-module": ["mcp-module"],
+    };
+    function getObjectPromptDependencies() {
+        return OBJECT_PROMPT_DEPENDENCIES;
+    }
+    function buildPrompts(repoPath) {
+        return [
+            {
+                name: "decoration-overview",
+                description: "High-level guidance on using the decoration library: key exports, decorators, and common workflows.",
+                load: async () => `You are assisting with the Decaf.ts decoration module located at ${repoPath}. Prefer using exported builders and decorators over ad-hoc patterns.\n\nProvide a concise, actionable overview of how to use the decoration APIs for extending and overriding behaviors.`,
+            },
+        ];
+    }
+    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 summarizePromptContent(prompt, headingPrefix) {
+        return [`## ${headingPrefix}`, "", prompt.content.trim()].join("\n");
+    }
+    function buildObjectPrompts() {
+        const root = getWorkspaceRoot();
+        const discovered = discoverDocPrompts(root);
+        const promptByName = new Map();
+        for (const prompt of discovered) {
+            promptByName.set(prompt.name, prompt);
+        }
+        const outputs = [];
+        for (const [objectType, dependencies] of Object.entries(OBJECT_PROMPT_DEPENDENCIES)) {
+            const existing = dependencies
+                .map((name) => promptByName.get(name))
+                .filter((prompt) => Boolean(prompt));
+            if (!existing.length)
+                continue;
+            outputs.push({
+                name: `codex/${objectType}`,
+                description: `Guidance derived from .codex prompts for ${objectType} tasks.`,
+                load: async () => {
+                    const sections = existing.map((prompt) => summarizePromptContent(prompt, toTitleCase(prompt.name)));
+                    return [`# Codex guidance for ${objectType}`, "", ...sections].join("\n");
+                },
+            });
+        }
+        return outputs.sort((a, b) => a.name.localeCompare(b.name));
+    }
+    function toInputPrompt(asset) {
+        const provenance = asset.provenance ? ` (module: ${asset.provenance})` : "";
+        return {
+            name: asset.id,
+            description: `${asset.description ?? asset.title}${provenance}`,
+            load: async () => asset.load(),
+        };
+    }
+    function buildModulePrompts() {
+        return moduleRegistry.listPrompts().map(toInputPrompt);
+    }
+    function refreshPrompts(repoPath) {
+        const docPrompts = buildDocPrompts();
+        const objectPrompts = buildObjectPrompts();
+        const repoPrompts = repoPath ? buildPrompts(repoPath) : [];
+        const modulePrompts = buildModulePrompts();
+        prompts.splice(0, prompts.length, ...docPrompts, ...objectPrompts, ...repoPrompts, ...modulePrompts);
+        return prompts;
+    }
+    function discoverDocPrompts(root) {
+        const discovered = [];
+        for (const directory of PROMPT_DIRECTORIES) {
+            const promptDir = path.join(root, directory);
+            // debug logging to help tests diagnose prompt discovery
+            console.debug("[discoverDocPrompts] checking", promptDir);
+            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(promptList, requestedName) {
+        const direct = promptList.find((prompt) => prompt.name === requestedName);
+        if (direct)
+            return direct;
+        const fallback = promptList.find((prompt) => prompt.name === DEFAULT_PROMPT_NAME);
+        if (fallback)
+            return fallback;
+        if (!promptList.length) {
+            throw new Error("No documentation prompts available");
+        }
+        return promptList[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";
         }
     }
 
+    const promptList = prompts;
+    function loadPrompts(repoPath) {
+        return refreshPrompts(repoPath);
+    }
+
     function escapeRegExp(value) {
         return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     }
@@ -247,224 +1211,522 @@
                 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.",
+                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 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";
-        }
+    };
+
+    function relativeFiles(root, files) {
+        return files.map((file) => path.relative(root, file)).sort();
     }
-    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";
-                    }
-                };
+    function collectPromptSections(names) {
+        const root = getWorkspaceRoot();
+        const promptIndex = new Map(discoverDocPrompts(root).map((prompt) => [prompt.name, prompt]));
+        return names
+            .map((name) => promptIndex.get(name))
+            .filter((prompt) => Boolean(prompt))
+            .map((prompt) => ({
+            name: prompt.name,
+            title: prompt.title,
+            description: prompt.description,
+            content: prompt.content,
+            absolutePath: prompt.absolutePath,
+        }));
+    }
+    function parseTaskLines(content) {
+        return content
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => /^task\s+\d+/i.test(line));
+    }
+    function computeCoverageFromFinal(coveragePath) {
+        const payload = JSON.parse(fs.readFileSync(coveragePath, "utf8"));
+        const totals = {
+            statements: { covered: 0, total: 0 },
+            functions: { covered: 0, total: 0 },
+            branches: { covered: 0, total: 0 },
+        };
+        const files = Object.entries(payload).map(([filePath, info]) => {
+            const statementCounts = Object.values(info.s);
+            const functionCounts = Object.values(info.f);
+            const branchCounts = Object.values(info.b).flatMap((value) => Array.isArray(value) ? value : [value]);
+            const statementTotal = statementCounts.length;
+            const functionTotal = functionCounts.length;
+            const branchTotal = branchCounts.length;
+            const statementCovered = statementCounts.filter((count) => count > 0).length;
+            const functionCovered = functionCounts.filter((count) => count > 0).length;
+            const branchCovered = branchCounts.filter((count) => count > 0).length;
+            totals.statements.covered += statementCovered;
+            totals.statements.total += statementTotal;
+            totals.functions.covered += functionCovered;
+            totals.functions.total += functionTotal;
+            totals.branches.covered += branchCovered;
+            totals.branches.total += branchTotal;
+            const pct = (covered, total) => total === 0 ? 100 : Number(((covered / total) * 100).toFixed(2));
+            return {
+                path: filePath,
+                statements: pct(statementCovered, statementTotal),
+                functions: pct(functionCovered, functionTotal),
+                branches: pct(branchCovered, branchTotal),
+            };
+        });
+        const pct = (covered, total) => total === 0 ? 100 : Number(((covered / total) * 100).toFixed(2));
+        return {
+            totals: {
+                statements: {
+                    ...totals.statements,
+                    pct: pct(totals.statements.covered, totals.statements.total),
+                },
+                functions: {
+                    ...totals.functions,
+                    pct: pct(totals.functions.covered, totals.functions.total),
+                },
+                branches: {
+                    ...totals.branches,
+                    pct: pct(totals.branches.covered, totals.branches.total),
+                },
+            },
+            files,
+        };
+    }
+    function normalizePromptSections(sections) {
+        return sections.map((section) => ({
+            name: section.name,
+            title: section.title,
+            tasks: parseTaskLines(section.content),
+            content: section.content,
+        }));
+    }
+    async function resolveRepoRoot(basePath) {
+        const root = getWorkspaceRoot();
+        try {
+            return resolveInWorkspace(root, basePath);
+        }
+        catch (error) {
+            if (error instanceof WorkspaceError) {
+                await throwUserError(error.message);
             }
+            throw error;
         }
-        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.",
+    const documentObjectTool = {
+        name: "document-object",
+        description: "Create a documentation plan for a specific object type using .codex prompts and repository analysis.",
+        parameters: documentObjectSchema,
         // 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);
+            const args = documentObjectSchema.parse(input);
+            const repoRoot = await resolveRepoRoot(args.basePath);
+            const dependencies = getObjectPromptDependencies()[args.objectType] ?? [];
+            if (!dependencies.length) {
+                await throwUserError(`No prompt guidance configured for object type ${args.objectType}`);
             }
-            catch (error) {
-                if (error instanceof WorkspaceError) {
-                    return throwUserError(error.message);
+            const sections = normalizePromptSections(collectPromptSections(dependencies));
+            const srcDir = path.join(repoRoot, "src");
+            const testDir = path.join(repoRoot, "tests");
+            const sourceFiles = fs.existsSync(srcDir)
+                ? listFilesRecursive(srcDir, isSourceFile)
+                : [];
+            const testFiles = fs.existsSync(testDir)
+                ? listFilesRecursive(testDir, (file) => isSourceFile(file) && isTestFile(file))
+                : [];
+            let targetFileContent;
+            if (args.targetFile) {
+                try {
+                    const absolute = resolveInWorkspace(repoRoot, args.targetFile);
+                    targetFileContent = readFileSafe(absolute) ?? undefined;
+                }
+                catch (error) {
+                    if (error instanceof WorkspaceError) {
+                        await throwUserError(error.message);
+                    }
+                    throw error;
                 }
-                /* 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,
-            });
+            const payload = {
+                basePath: path.relative(getWorkspaceRoot(), repoRoot) || ".",
+                objectType: args.objectType,
+                targetFile: args.targetFile,
+                guidance: sections,
+                files: {
+                    source: relativeFiles(repoRoot, sourceFiles),
+                    tests: relativeFiles(repoRoot, testFiles),
+                },
+                targetFileContent: args.includeContent ? targetFileContent : undefined,
+            };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(payload, null, 2),
+                    },
+                ],
+            };
         },
-        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.",
+    const coverageEnforcerTool = {
+        name: "ensure-test-coverage",
+        description: "Run the configured coverage command and report whether the target percentage is met, highlighting weak files.",
+        parameters: coverageTaskSchema,
         // 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}`);
-            }
+            const args = coverageTaskSchema.parse(input);
+            const repoRoot = await resolveRepoRoot(args.basePath);
             if (!args.dryRun) {
-                fs.mkdirSync(path.dirname(filePath), { recursive: true });
-                fs.writeFileSync(filePath, patched, {
-                    encoding: args.encoding,
-                });
+                const env = {
+                    ...process.env,
+                    USE_WATCHMAN: "false",
+                    WATCHMAN_DISABLE: "1",
+                    JEST_DISABLE_WATCHMAN: "1",
+                };
+                const result = child_process.spawnSync("npm", ["run", "coverage", "--", "--watchman=false", "--runInBand"], { cwd: repoRoot, env, encoding: "utf8" });
+                if (result.status !== 0) {
+                    const message = result.stderr || result.stdout || "Coverage command failed";
+                    await throwUserError(message.trim());
+                }
             }
-            if (!args.showDiff) {
-                return `Patch ${args.dryRun ? "validated" : "applied"} for ${args.filePath}`;
+            const coveragePath = path.join(repoRoot, "workdocs", "reports", "coverage", "coverage-final.json");
+            if (!fs.existsSync(coveragePath)) {
+                await throwUserError(`Coverage report not found at ${path.relative(repoRoot, coveragePath)}`);
             }
-            const preview = diff.createTwoFilesPatch(args.filePath, args.filePath, original, patched, undefined, undefined, { context: args.diffContext });
+            const summary = computeCoverageFromFinal(coveragePath);
+            const meetsThreshold = summary.totals.statements.pct >= args.coverage &&
+                summary.totals.functions.pct >= args.coverage &&
+                summary.totals.branches.pct >= args.coverage;
+            const weakest = [...summary.files]
+                .sort((a, b) => a.statements - b.statements)
+                .slice(0, 10);
+            const guidance = normalizePromptSections(collectPromptSections(["bulk-tests"]));
+            const payload = {
+                basePath: path.relative(getWorkspaceRoot(), repoRoot) || ".",
+                target: args.coverage,
+                meetsThreshold,
+                totals: summary.totals,
+                weakest,
+                guidance,
+            };
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Patch ${args.dryRun ? "validated" : "applied"} for ${args.filePath}`,
+                        text: JSON.stringify(payload, null, 2),
                     },
+                ],
+            };
+        },
+    };
+    const readmeImprovementTool = {
+        name: "improve-readme",
+        description: "Summarize required steps to refresh README and workdocs content using .codex guidance and repository analysis.",
+        parameters: readmeImprovementSchema,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        execute: async (input, _context) => {
+            const args = readmeImprovementSchema.parse(input);
+            const repoRoot = await resolveRepoRoot(args.basePath);
+            const analysis = analyzeRepo(repoRoot);
+            const modules = analysis.files
+                .filter((file) => /index\.ts$/.test(file))
+                .map((file) => path.relative(repoRoot, file));
+            const promptSections = normalizePromptSections(collectPromptSections(["update-readme", "doc", "module"]));
+            const testExamples = Object.keys(analysis.tests ?? {});
+            const examples = args.includeExamples ? testExamples.slice(0, 20) : [];
+            const payload = {
+                basePath: path.relative(getWorkspaceRoot(), repoRoot) || ".",
+                summary: {
+                    modules,
+                    totalSourceFiles: analysis.files.length,
+                    totalTestFiles: analysis.testFiles.length,
+                    hasReadme: Boolean(analysis.readme),
+                },
+                guidance: promptSections,
+                suggestedExamples: examples,
+            };
+            return {
+                content: [
                     {
                         type: "text",
-                        text: ["```diff", preview.trim(), "```"].join("\n"),
+                        text: JSON.stringify(payload, null, 2),
                     },
                 ],
             };
         },
-        name: "apply-code-change",
-        parameters: codeChangeSchema,
     };
-    const tools = {
-        ...decoratorTools,
-        documentCodeTool,
-        applyCodeChangeTool,
+
+    const DEFAULT_PLACEHOLDERS = {
+        prompts: `export const promptList = [
+  {
+    id: "example-prompt",
+    title: "Example prompt",
+    description: "A placeholder prompt created by scaffoldModule",
+    content: "Describe the task for the assistant...",
+    absolutePath: __filename,
+  },
+] as const;
+`,
+        resources: `export const resources = [
+  {
+    id: "example-resource",
+    name: "Example Resource",
+    description: "A placeholder resource created by scaffoldModule",
+    uri: "file://placeholder",
+    absolutePath: __filename,
+  },
+] as const;
+`,
+        templates: `export const templates = [
+  {
+    name: "example-template",
+    description: "A placeholder template created by scaffoldModule",
+    uriTemplate: "file://template/{path}",
+    mimeType: "text/plain",
+  },
+] as const;
+`,
+        tools: `export const toolList = [
+  {
+    id: "example-tool",
+    name: "example-tool",
+    description: "A placeholder tool created by scaffoldModule",
+    run: async () => ({ result: "placeholder" }),
+  },
+] as const;
+`,
     };
-    function enrich(mcp) {
-        for (const prompt of buildDocPrompts()) {
-            mcp.addPrompt(prompt);
+    /**
+     * Create a module scaffold under repoRoot/src/modules/<moduleName>
+     * Returns created files list.
+     */
+    function scaffoldModule(repoRoot, moduleName) {
+        if (!repoRoot)
+            throw new Error("repoRoot is required");
+        if (!moduleName)
+            throw new Error("moduleName is required");
+        const modulePath = path.join(repoRoot, "src", "modules", moduleName);
+        const createdFiles = [];
+        const subfolders = ["prompts", "resources", "templates", "tools"];
+        for (const folder of subfolders) {
+            const folderPath = path.join(modulePath, folder);
+            fs.mkdirSync(folderPath, { recursive: true });
+            const indexPath = path.join(folderPath, "index.ts");
+            // if file exists, skip writing
+            if (!fs.existsSync(indexPath)) {
+                // insert __filename for absolutePath in placeholders
+                const content = DEFAULT_PLACEHOLDERS[folder].replace(/__filename/g, JSON.stringify(indexPath));
+                fs.writeFileSync(indexPath, content, { encoding: "utf8" });
+                createdFiles.push(indexPath);
+            }
         }
-        for (const tool of Object.values(tools)) {
-            mcp.addTool(tool);
+        return { modulePath, createdFiles };
+    }
+    // CLI support when required directly via ts-node registration
+    if (require.main === module) {
+        const [, , moduleName] = process.argv;
+        if (!moduleName) {
+            console.error("Usage: scaffold-module <module-name>");
+            process.exit(1);
         }
-        for (const template of buildResourceTemplates()) {
-            mcp.addResourceTemplate(template);
+        try {
+            const res = scaffoldModule(process.cwd(), moduleName);
+            console.log("Scaffolded module:", res.modulePath);
+            for (const f of res.createdFiles)
+                console.log("  created:", f);
+            process.exit(0);
+        }
+        catch (err) {
+            console.error(err && err.message ? err.message : err);
+            process.exit(2);
         }
-        return mcp;
     }
-    const PACKAGE_NAME = PACKAGE_NAME$1;
-    const VERSION = VERSION$1;
-    function setWorkspaceRoot(root) {
-        workspaceRoot = path.resolve(root);
+
+    // New tool: generate-mcp-module
+    zod.z.object({
+        repoPath: zod.z.string().optional().default("."),
+        moduleName: zod.z.string().optional(),
+        includeDocs: zod.z.boolean().default(true),
+    });
+
+    const codexToolList = [
+        documentObjectTool,
+        coverageEnforcerTool,
+        readmeImprovementTool,
+    ];
+    const moduleToolList = moduleRegistry.listTools().map((asset) => asset.tool);
+    const toolList = [...toolList$1, ...codexToolList, ...moduleToolList];
+    const [analyzeRepositoryTool, enumerateCapabilitiesTool, planFeatureTool, documentCodeToolRef, applyCodeChangeToolRef,] = toolList$1;
+    const tools = {
+        analyzeRepositoryTool,
+        enumerateCapabilitiesTool,
+        planFeatureTool,
+        documentCodeTool: documentCodeToolRef,
+        applyCodeChangeTool: applyCodeChangeToolRef,
+        documentObjectTool,
+        coverageEnforcerTool,
+        readmeImprovementTool,
+        ...decoratorTools,
+    };
+
+    function toResource(asset) {
+        return {
+            name: asset.id,
+            uri: asset.uri,
+            description: asset.description ?? asset.title,
+            mimeType: asset.mimeType,
+            load: async () => {
+                const res = await asset.load();
+                // asset.load may return a ContentResult or a Promise of ContentResult; ensure we return ResourceResult-like object
+                if (res?.content) {
+                    const cr = res;
+                    // If ContentResult, convert to simple text result expected by Resource.load consumers
+                    return {
+                        text: Array.isArray(cr.content)
+                            ? cr.content.map((c) => c.text).join("\n")
+                            : String(cr),
+                    };
+                }
+                // fallback for objects with text
+                return res;
+            },
+        };
     }
-    function getWorkspaceRoot() {
-        return workspaceRoot;
+    function buildModuleResources() {
+        return moduleRegistry.listResources().map(toResource);
+    }
+    const resources = [
+        {
+            name: "codex-prompt-index",
+            uri: "codex://prompts/index",
+            description: "Enumerate available .codex prompt files with titles and descriptions.",
+            mimeType: "application/json",
+            load: async () => {
+                const root = getWorkspaceRoot();
+                const prompts = discoverDocPrompts(root).map((prompt) => ({
+                    name: prompt.name,
+                    title: prompt.title,
+                    description: prompt.description,
+                    path: prompt.absolutePath,
+                }));
+                return {
+                    text: JSON.stringify({ prompts }, null, 2),
+                    mimeType: "application/json",
+                };
+            },
+        },
+        {
+            name: "codex-object-prompts",
+            uri: "codex://prompts/objects",
+            description: "Provides the resolved prompt content for each documented object workflow.",
+            mimeType: "application/json",
+            load: async () => {
+                const entries = await Promise.all(buildObjectPrompts().map(async (prompt) => ({
+                    name: prompt.name,
+                    description: prompt.description,
+                    content: await prompt.load({}),
+                })));
+                return {
+                    text: JSON.stringify({ prompts: entries }, null, 2),
+                    mimeType: "application/json",
+                };
+            },
+        },
+        ...buildModuleResources(),
+    ];
+
+    const codexPromptTemplates = [];
+    function buildCodexPromptTemplates() {
+        const root = getWorkspaceRoot();
+        const templates = [
+            {
+                name: "codex-prompt",
+                description: "Load a .codex prompt file by name (without extension) as markdown.",
+                uriTemplate: "codex-prompt://{name}",
+                mimeType: "text/markdown",
+                arguments: [
+                    {
+                        name: "name",
+                        description: "Name of the prompt file inside .codex/prompts (without .md).",
+                        required: true,
+                    },
+                ],
+                load: async ({ name }) => {
+                    const promptPath = resolveInWorkspace(root, path.join(".codex", "prompts", `${name}.md`));
+                    if (!fs.existsSync(promptPath)) {
+                        throw new Error(`Prompt .codex/prompts/${name}.md not found`);
+                    }
+                    const text = fs.readFileSync(promptPath, "utf8");
+                    return { text, uri: `codex-prompt:///${name}` };
+                },
+            },
+        ];
+        codexPromptTemplates.splice(0, codexPromptTemplates.length, ...templates);
+        return codexPromptTemplates;
+    }
+
+    const decorationResourceTemplates = [];
+    function makeLoader(type) {
+        return async ({ path: relative }) => {
+            const root = getWorkspaceRoot();
+            const target = path.join(type, relative);
+            const text = await readWorkspaceFile(root, target);
+            return { text };
+        };
+    }
+    function buildDecorationResourceTemplates() {
+        const templates = [
+            {
+                name: "read-code-from-source",
+                description: "Read a file from the <base_path>/src tree by relative path.",
+                mimeType: "text/plain",
+                uriTemplate: "from-source://src/{path}",
+                arguments: [
+                    {
+                        name: "path",
+                        description: "Path under <base_path>/src to load, e.g. 'decoration/types.ts'",
+                        required: true,
+                    },
+                ],
+                load: makeLoader("src"),
+            },
+            {
+                name: "read-test-from-source",
+                description: "Read a file from the <base_path>/tests tree by relative path.",
+                mimeType: "text/plain",
+                uriTemplate: "from-source://tests/{path}",
+                arguments: [
+                    {
+                        name: "path",
+                        description: "Path under <base_path>/tests to load, e.g. 'decoration/tests/types.test.ts'",
+                        required: true,
+                    },
+                ],
+                load: makeLoader("tests"),
+            },
+            {
+                name: "read-doc-from-source",
+                description: "Read a file from the <base_path>/workdocs tree by relative path.",
+                mimeType: "text/plain",
+                uriTemplate: "from-source://workdocs/{path}",
+                arguments: [
+                    {
+                        name: "path",
+                        description: "Path under <base_path>/workdocs to load, e.g. 'decoration/workdocs/tutorials/for-developers.md'",
+                        required: true,
+                    },
+                ],
+                load: makeLoader("workdocs"),
+            },
+        ];
+        decorationResourceTemplates.splice(0, decorationResourceTemplates.length, ...templates);
+        return decorationResourceTemplates;
     }
-    function buildResourceTemplates() {
+
+    const workspaceResourceTemplates = [];
+    function buildWorkspaceResourceTemplates() {
         const root = getWorkspaceRoot();
         const sharedArguments = [
             {
@@ -473,7 +1735,7 @@
                 required: true,
             },
         ];
-        return [
+        const templates = [
             {
                 name: "vscode-workspace-file",
                 description: "Expose workspace files to Visual Studio Code via vscode:// URIs",
@@ -481,8 +1743,14 @@
                 mimeType: "text/plain",
                 arguments: sharedArguments,
                 load: async (args) => {
-                    const text = await readWorkspaceFile(root, args.path);
-                    return { text };
+                    try {
+                        const text = await readWorkspaceFile(root, args.path);
+                        return { text: String(text) };
+                    }
+                    catch (err) {
+                        // propagate as-is for tests to assert errors
+                        throw err;
+                    }
                 },
             },
             {
@@ -492,8 +1760,13 @@
                 mimeType: "text/plain",
                 arguments: sharedArguments,
                 load: async (args) => {
-                    const text = await readWorkspaceFile(root, args.path);
-                    return { text };
+                    try {
+                        const text = await readWorkspaceFile(root, args.path);
+                        return { text: String(text) };
+                    }
+                    catch (err) {
+                        throw err;
+                    }
                 },
             },
             {
@@ -503,164 +1776,510 @@
                 mimeType: "text/plain",
                 arguments: sharedArguments,
                 load: async (args) => {
-                    const text = await readWorkspaceFile(root, args.path);
-                    return { text };
+                    try {
+                        const text = await readWorkspaceFile(root, args.path);
+                        return { text: String(text) };
+                    }
+                    catch (err) {
+                        throw err;
+                    }
                 },
             },
         ];
+        workspaceResourceTemplates.splice(0, workspaceResourceTemplates.length, ...templates);
+        return workspaceResourceTemplates;
     }
-    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,
+
+    function buildResourceTemplates() {
+        const moduleTemplates = moduleRegistry.listTemplates().map((template) => ({
+            name: template.id,
+            description: template.description ?? template.title,
+            mimeType: "text/markdown",
+            uriTemplate: `module-template://${template.id}`,
+            arguments: (template.placeholders ?? []).map((name) => ({
+                name,
+                description: `Value for ${name}`,
+                required: true,
+            })),
+            load: async () => ({
+                text: typeof template.content === "string"
+                    ? template.content
+                    : `# ${template.description ?? template.title ?? template.id}\n\nNo template content available for ${template.id}`,
+            }),
         }));
-        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.`,
+        const all = [
+            ...buildWorkspaceResourceTemplates(),
+            ...buildCodexPromptTemplates(),
+            ...buildDecorationResourceTemplates(),
+            ...moduleTemplates,
+        ];
+        // Normalise all loaders to always return { text: string }
+        function normaliseResult(res) {
+            if (res == null)
+                return { text: "" };
+            if (typeof res === "string")
+                return { text: res };
+            if (typeof res.text === "string")
+                return res;
+            // handle legacy ContentResult shapes with content or content array
+            if (Array.isArray(res.content)) {
+                const parts = res.content
+                    .map((c) => (c && typeof c.text === "string" ? c.text : String(c)))
+                    .join("\n");
+                return { text: parts };
+            }
+            if (res.content && typeof res.content.text === "string") {
+                return { text: res.content.text };
+            }
+            // fallback: stringify
+            try {
+                return { text: JSON.stringify(res) };
+            }
+            catch {
+                return { text: String(res) };
+            }
+        }
+        return all.map((t) => ({
+            ...t,
+            load: async (args) => {
+                const raw = await t.load(args);
+                return normaliseResult(raw);
+            },
         }));
-        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}`);
+    const templateList = buildResourceTemplates();
+
+    /**
+     * @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$1 = "0.1.0";
+    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;
         }
-        return resolved;
     }
-    async function readWorkspaceFile(root, target) {
-        try {
-            const absolute = resolveInWorkspace(root, target);
-            return fs.readFileSync(absolute, "utf8");
+
+    function enrich(mcp) {
+        const promptEntries = loadPrompts();
+        for (const prompt of promptEntries) {
+            mcp.addPrompt(prompt);
         }
-        catch (error) {
-            if (error instanceof WorkspaceError) {
-                await throwUserError(error.message);
+        for (const tool of toolList) {
+            mcp.addTool(tool);
+        }
+        const templates = buildResourceTemplates();
+        for (const template of templates) {
+            mcp.addResourceTemplate(template);
+        }
+        for (const resource of resources) {
+            const addResource = mcp.addResource;
+            if (typeof addResource === "function") {
+                addResource.call(mcp, resource);
             }
-            /* istanbul ignore next */
-            throw error;
         }
+        return mcp;
+    }
+    const PACKAGE_NAME = PACKAGE_NAME$1;
+    const VERSION = VERSION$1;
+
+    // New: validation entrypoint for module structure
+    const REQUIRED_SUBFOLDERS = ["prompts", "resources", "templates", "tools"];
+    function findModuleDirs(repoRoot) {
+        const modulesPath = path.resolve(repoRoot, "src", "modules");
+        if (!fs.existsSync(modulesPath) || !fs.statSync(modulesPath).isDirectory()) {
+            return [];
+        }
+        return fs
+            .readdirSync(modulesPath, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => path.join(modulesPath, d.name));
     }
-    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())
+    function hasIndexExport(folderPath) {
+        const candidates = [
+            "index.ts",
+            "index.tsx",
+            "index.js",
+            "index.cjs",
+            "index.mjs",
+        ];
+        for (const c of candidates) {
+            if (fs.existsSync(path.join(folderPath, c)))
+                return true;
+        }
+        return false;
+    }
+    function validateModules(repoRoot) {
+        const dirs = findModuleDirs(repoRoot);
+        const issues = [];
+        for (const moduleDir of dirs) {
+            const moduleName = path.basename(moduleDir);
+            for (const sub of REQUIRED_SUBFOLDERS) {
+                const subPath = path.join(moduleDir, sub);
+                if (!fs.existsSync(subPath) || !fs.statSync(subPath).isDirectory()) {
+                    issues.push({
+                        module: moduleName,
+                        path: subPath,
+                        type: "missing-folder",
+                        detail: `Required folder '${sub}' is missing in module '${moduleName}'`,
+                    });
                     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,
-                });
+                }
+                // If folder exists, check for index export
+                if (!hasIndexExport(subPath)) {
+                    issues.push({
+                        module: moduleName,
+                        path: subPath,
+                        type: "missing-export",
+                        detail: `No index export found in '${subPath}'. Expected one of index.ts, index.js, etc.`,
+                    });
+                    continue;
+                }
+                // Optionally inspect the index file to see if it exports a list (lightweight check)
+                try {
+                    const indexFile = candidatesFindingIndex(subPath);
+                    if (indexFile) {
+                        const content = fs.readFileSync(indexFile, "utf8");
+                        // crude heuristics: look for `export const name = [` or `export const name: Type[] = [`,
+                        // or any named export like `export { something }` which implies exports exist.
+                        const exportListPattern = /export\s+(const|let|var)\s+[\w$]+(?:\s*:\s*[^=]+)?\s*=\s*\[/;
+                        if (!exportListPattern.test(content) &&
+                            !/export\s+\{/.test(content)) {
+                            issues.push({
+                                module: moduleName,
+                                path: indexFile,
+                                type: "empty-list",
+                                detail: `Index file does not appear to export a list of assets: ${path.basename(indexFile)}`,
+                            });
+                        }
+                    }
+                }
+                catch (err) {
+                    issues.push({
+                        module: moduleName,
+                        path: subPath,
+                        type: "other",
+                        detail: `Error reading index file: ${err.message}`,
+                    });
+                }
             }
         }
-        const unique = new Map();
-        for (const prompt of discovered) {
-            if (!unique.has(prompt.name)) {
-                unique.set(prompt.name, prompt);
-            }
+        return {
+            ok: issues.length === 0,
+            modulesChecked: dirs.length,
+            issues,
+        };
+    }
+    function candidatesFindingIndex(folderPath) {
+        const candidates = [
+            "index.ts",
+            "index.tsx",
+            "index.js",
+            "index.cjs",
+            "index.mjs",
+        ];
+        for (const c of candidates) {
+            const full = path.join(folderPath, c);
+            if (fs.existsSync(full))
+                return full;
         }
-        return Array.from(unique.values()).sort((a, b) => a.name.localeCompare(b.name));
+        return undefined;
     }
-    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");
+    // CLI helper
+    if (require.main === module) {
+        const repoRoot = process.cwd();
+        const report = validateModules(repoRoot);
+        if (!report.ok) {
+            console.error("Module validation failed:\n", JSON.stringify(report, null, 2));
+            process.exit(2);
         }
-        return prompts[0];
+        console.log("Module validation passed");
+        process.exit(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}`);
+
+    // Aggregator: import module index files and merge exported arrays with provenance + duplicate detection
+    const SUBFOLDERS = ["prompts", "resources", "templates", "tools"];
+    const INDEX_CANDIDATES = [
+        "index.ts",
+        "index.tsx",
+        "index.js",
+        "index.cjs",
+        "index.mjs",
+    ];
+    function findIndexFile(folder) {
+        for (const c of INDEX_CANDIDATES) {
+            const f = path.join(folder, c);
+            if (fs.existsSync(f))
+                return f;
         }
-        if (includePrompt) {
-            sections.push(`## Prompt Guidance (${prompt.title})\n\n${prompt.content.trim()}`);
+        return undefined;
+    }
+    function makeKeyForItem(item) {
+        if (!item)
+            return JSON.stringify(item);
+        if (typeof item === "string")
+            return `str:${item}`;
+        if (typeof item === "number")
+            return `num:${item}`;
+        if (item.id)
+            return `id:${item.id}`;
+        if (item.name)
+            return `name:${item.name}`;
+        // fallback to stable string
+        try {
+            return `obj:${JSON.stringify(item)}`;
         }
-        if (additionalContext?.trim()) {
-            sections.push(`## Additional Context\n\n${additionalContext.trim()}`);
+        catch (e) {
+            return `obj:${String(item)}`;
         }
-        if (includeCode) {
-            sections.push(`## Source\n\n\`\`\`${inferLanguageFromPath(filePath)}\n${fileContent}\n\`\`\``);
+    }
+    async function loadArrayFromIndex(filePath) {
+        // Prefer a fast, static parse of the first array literal found in the file.
+        try {
+            const content = fs.readFileSync(filePath, "utf8");
+            const start = content.indexOf("[");
+            if (start !== -1) {
+                let depth = 0;
+                let end = -1;
+                for (let i = start; i < content.length; i++) {
+                    const ch = content[i];
+                    if (ch === "[")
+                        depth++;
+                    else if (ch === "]") {
+                        depth--;
+                        if (depth === 0) {
+                            end = i;
+                            break;
+                        }
+                    }
+                }
+                if (end !== -1) {
+                    const arrText = content.slice(start, end + 1);
+                    try {
+                        return JSON.parse(arrText);
+                    }
+                    catch (e) {
+                        // Normalize TS object literals to JSON:
+                        // - convert single quotes to double quotes
+                        // - quote unquoted object keys
+                        // - strip trailing commas
+                        const normalized = arrText
+                            // unify quotes in string literals
+                            .replace(/'(?:\\'|[^'])*'/g, (m) => m.replace(/'/g, '"'))
+                            // quote unquoted keys after { or ,
+                            .replace(/([\{,]\s*)([A-Za-z_$][\w$]*)(\s*:)/g, '$1"$2"$3')
+                            // remove trailing commas before ] or }
+                            .replace(/,(\s*[\}\]])/g, '$1');
+                        try {
+                            return JSON.parse(normalized);
+                        }
+                        catch (e2) {
+                            // fallthrough to import attempt below
+                        }
+                    }
+                }
+            }
         }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: sections.join("\n\n"),
-                },
-            ],
+        catch (e) {
+            // ignore static parse errors and fall back to import
+        }
+        try {
+            const fileUrl = url.pathToFileURL(filePath).href;
+            const mod = await import(fileUrl);
+            // Find first export that is an array
+            for (const key of Object.keys(mod)) {
+                const val = mod[key];
+                if (Array.isArray(val))
+                    return val;
+            }
+            // default export check
+            if (Array.isArray(mod.default))
+                return mod.default;
+            return undefined;
+        }
+        catch (err) {
+            // fallback: if import fails, try to static-parse again (already attempted) and finally return undefined
+            return undefined;
+        }
+    }
+    async function aggregateModules(repoRoot) {
+        const dirs = findModuleDirs(repoRoot);
+        const master = {
+            prompts: [],
+            resources: [],
+            templates: [],
+            tools: [],
+            conflicts: [],
+        };
+        // maps to detect duplicates per type
+        const maps = {
+            prompts: new Map(),
+            resources: new Map(),
+            templates: new Map(),
+            tools: new Map(),
         };
+        for (const moduleDir of dirs) {
+            const moduleName = path.basename(moduleDir);
+            for (const sub of SUBFOLDERS) {
+                const folder = path.join(moduleDir, sub);
+                const indexFile = findIndexFile(folder);
+                if (!indexFile)
+                    continue;
+                let arr;
+                try {
+                    arr = await loadArrayFromIndex(indexFile);
+                }
+                catch (err) {
+                    // skip module on import error but record as conflict-like issue
+                    master.conflicts.push({
+                        key: `import-error:${moduleName}:${sub}`,
+                        existing: { moduleName, modulePath: moduleDir },
+                        incoming: { moduleName, modulePath: moduleDir },
+                    });
+                    continue;
+                }
+                if (!arr || !Array.isArray(arr))
+                    continue;
+                for (const item of arr) {
+                    const key = makeKeyForItem(item);
+                    const provenance = { moduleName, modulePath: moduleDir };
+                    const map = maps[sub];
+                    if (map.has(key)) {
+                        // record conflict deterministically (existing vs incoming)
+                        const existing = map.get(key);
+                        master.conflicts.push({ key, existing, incoming: provenance });
+                        // skip adding duplicate
+                        continue;
+                    }
+                    map.set(key, provenance);
+                    master[sub].push({ ...item, provenance });
+                }
+            }
+        }
+        return master;
     }
-    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)}`);
+    // For compatibility with CommonJS call sites (not exported by ESM), provide a sync wrapper
+    function aggregateModulesSync(repoRoot) {
+        // synchronous wrapper that runs the async function and blocks — suitable for small module sets
+        const p = aggregateModules(repoRoot);
+        let result;
+        let done = false;
+        p.then((r) => {
+            result = r;
+            done = true;
+        }).catch((e) => {
+            throw e;
+        });
+        if (!done)
+            throw new Error("aggregateModulesSync: timeout waiting for async aggregation");
+        return result;
     }
-    function toTitleCase(value) {
-        return value
-            .split(/\s+/)
-            .filter(Boolean)
-            .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
-            .join(" ");
+
+    /**
+     * Aggregate module assets and register them on the provided FastMCP-like server.
+     * Falls back to built-in lists if aggregation yields none.
+     */
+    async function EnrichCoreWithAggregation(server, repoRoot = process.cwd()) {
+        // First register built-in prompts/tools/resources/templates (legacy behavior)
+        try {
+            loadPrompts();
+            for (const prompt of promptList)
+                server.addPrompt(prompt);
+        }
+        catch (e) {
+            // ignore if loadPrompts not available or fails
+        }
+        try {
+            for (const tool of toolList)
+                server.addTool(tool);
+        }
+        catch (e) { }
+        try {
+            for (const resource of resources)
+                server.addResource(resource);
+        }
+        catch (e) { }
+        try {
+            const templates = buildResourceTemplates();
+            for (const template of templates)
+                server.addResourceTemplate(template);
+        }
+        catch (e) { }
+        // Now aggregate modules and register aggregated assets with provenance
+        const agg = await aggregateModules(repoRoot);
+        for (const p of agg.prompts) {
+            server.addPrompt(p);
+        }
+        for (const t of agg.tools) {
+            server.addTool(t);
+        }
+        for (const r of agg.resources) {
+            server.addResource(r);
+        }
+        for (const tpl of agg.templates) {
+            server.addResourceTemplate(tpl);
+        }
+        // return aggregation summary for calling tests/CI
+        return {
+            modulesChecked: agg.prompts.concat(agg.tools).length,
+            conflicts: agg.conflicts,
+        };
     }
-    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";
+
+    function EnrichCore(server) {
+        loadPrompts();
+        for (const prompt of promptList) {
+            server.addPrompt(prompt);
+        }
+        for (const tool of toolList) {
+            server.addTool(tool);
+        }
+        for (const resource of resources) {
+            server.addResource(resource);
+        }
+        const templates = buildResourceTemplates();
+        for (const template of templates) {
+            server.addResourceTemplate(template);
         }
     }
 
-    /**
-     * @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
-     *
-     * @const MCP_FILE_NAME
-     * @memberOf module:MCP
-     */
-    const MCP_FILE_NAME = "mcp-module";
+    const REQUIRED_MODULE_FOLDERS = [
+        "prompts",
+        "resources",
+        "templates",
+        "tools",
+    ];
+    function resolveModulesRoot(workspaceRoot = getWorkspaceRoot()) {
+        return path$1.resolve(workspaceRoot, "src/modules");
+    }
+    function listModuleDirectories(workspaceRoot = getWorkspaceRoot()) {
+        const root = resolveModulesRoot(workspaceRoot);
+        if (!fs$1.existsSync(root))
+            return [];
+        return fs$1
+            .readdirSync(root)
+            .map((entry) => ({
+            entry,
+            absolute: path$1.join(root, entry),
+        }))
+            .filter(({ absolute }) => fs$1.statSync(absolute).isDirectory())
+            .map(({ entry }) => entry)
+            .sort();
+    }
+    function resolveModulePath(moduleName, workspaceRoot = getWorkspaceRoot()) {
+        return path$1.join(resolveModulesRoot(workspaceRoot), moduleName);
+    }
+    function resolveModuleFolderPath(moduleName, folder, workspaceRoot = getWorkspaceRoot()) {
+        return path$1.join(resolveModulePath(moduleName, workspaceRoot), folder);
+    }
 
     /* istanbul ignore file */
     /**
@@ -745,7 +2364,6 @@
         }
     }
 
-    /* istanbul ignore file */
     /**
      * @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.
@@ -774,7 +2392,7 @@
         /**
          * @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
+         * @return {FastMCP} The initialized Command object
          * @private
          */
         get mcp() {
@@ -849,24 +2467,26 @@
          */
         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")) {
+            // discover modules by crawling basePath
+            const moduleFiles = this.crawl(path.resolve(this.basePath), this.crawlLevels);
+            for (const moduleFile of moduleFiles) {
+                if (moduleFile.includes("@decaf-ts/mcp")) {
                     continue;
                 }
                 try {
-                    const res = await this.load(server, module);
+                    const res = await this.load(server, moduleFile);
                     server = res.mcp;
+                    this.modules[res.package] = moduleFile;
                 }
                 catch (e) {
-                    log.error(`Failed to load MCP configs for ${module}: ${e}`);
+                    log.error(`Failed to load MCP configs for ${moduleFile}: ${e instanceof Error ? e.message : 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
@@ -914,21 +2534,49 @@
          */
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         async run(args = process.argv) {
-            await this.boot();
+            const server = await this.boot();
+            await server.start({ transportType: "stdio" });
         }
     }
 
+    exports.CLIENT_INTEGRATIONS = CLIENT_INTEGRATIONS;
+    exports.DEFAULT_PROMPT_NAME = DEFAULT_PROMPT_NAME;
+    exports.EnrichCore = EnrichCore;
+    exports.EnrichCoreWithAggregation = EnrichCoreWithAggregation;
     exports.MCP_FILE_NAME = MCP_FILE_NAME;
     exports.McpUtils = McpUtils;
     exports.McpWrapper = McpWrapper;
     exports.PACKAGE_NAME = PACKAGE_NAME;
+    exports.PROMPT_DIRECTORIES = PROMPT_DIRECTORIES;
+    exports.REQUIRED_MODULE_FOLDERS = REQUIRED_MODULE_FOLDERS;
     exports.VERSION = VERSION;
+    exports.WORKSPACE_ROOT_ENV = WORKSPACE_ROOT_ENV;
+    exports.__resetWorkspaceRoot = __resetWorkspaceRoot;
+    exports.aggregateModules = aggregateModules;
+    exports.aggregateModulesSync = aggregateModulesSync;
+    exports.buildDecorationResourceTemplates = buildDecorationResourceTemplates;
     exports.buildDocPrompts = buildDocPrompts;
+    exports.buildDocumentationPayload = buildDocumentationPayload;
+    exports.buildPrompts = buildPrompts;
     exports.buildResourceTemplates = buildResourceTemplates;
+    exports.decorationResourceTemplates = decorationResourceTemplates;
+    exports.discoverDocPrompts = discoverDocPrompts;
     exports.enrich = enrich;
     exports.getWorkspaceRoot = getWorkspaceRoot;
+    exports.listModuleDirectories = listModuleDirectories;
+    exports.promptList = promptList;
+    exports.refreshPrompts = refreshPrompts;
+    exports.resolveModuleFolderPath = resolveModuleFolderPath;
+    exports.resolveModulePath = resolveModulePath;
+    exports.resolveModulesRoot = resolveModulesRoot;
+    exports.resources = resources;
+    exports.selectPrompt = selectPrompt;
     exports.setWorkspaceRoot = setWorkspaceRoot;
+    exports.templateList = templateList;
+    exports.toolList = toolList;
     exports.tools = tools;
+    exports.validateModules = validateModules;
+    exports.workspaceResourceTemplates = workspaceResourceTemplates;
 
 }));
-//# 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  }\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    await this.boot();\n  }\n}\n"],"names":["VERSION","PACKAGE_NAME","Metadata","z","applyPatch","createTwoFilesPatch","PKG","V","LoggedClass","FastMCP"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mcp-server.cjs","sources":["../src/constants.ts","../src/mcp/workspace.ts","../src/modules/decoration/prompts/index.ts","../src/modules/decoration/resources/index.ts","../src/modules/decoration/templates/index.ts","../src/mcp/schemas.ts","../src/mcp/utils.ts","../src/mcp/code.ts","../src/mcp/tools/tools.ts","../src/modules/decoration/tools/index.ts","../src/modules/decoration/index.ts","../src/modules/mcp/prompts/index.ts","../src/modules/mcp/resources/index.ts","../src/modules/mcp/templates/index.ts","../src/modules/mcp/tools/index.ts","../src/modules/mcp/index.ts","../src/modules/_template/prompts/index.ts","../src/modules/_template/resources/index.ts","../src/modules/_template/templates/index.ts","../src/modules/_template/tools/index.ts","../src/modules/_template/index.ts","../src/modules/index.ts","../src/mcp/moduleRegistry.ts","../src/mcp/prompts/prompts.ts","../src/mcp/prompts/index.ts","../src/mcp/decorator-tools.ts","../src/mcp/tools/codex-tools.ts","../src/mcp/validation/scaffoldModule.ts","../src/mcp/tools/generateMcpModule.ts","../src/mcp/tools/index.ts","../src/mcp/resources/resources.ts","../src/mcp/templates/codex-templates.ts","../src/mcp/templates/resource-templates.ts","../src/mcp/templates/workspace-templates.ts","../src/mcp/templates/index.ts","../src/metadata.ts","../src/mcp/mcp-module.ts","../src/mcp/validation/index.ts","../src/mcp/aggregateModules.ts","../src/mcp/fastmcp-wiring.ts","../src/mcp/index.ts","../src/utils/modulePaths.ts","../src/utils.ts","../src/McpWrapper.ts"],"sourcesContent":["/**\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\n\nexport const WORKSPACE_ROOT_ENV = \"MCP_WORKSPACE_ROOT\";\nexport const PROMPT_DIRECTORIES = [\".code/prompts\", \".codex/prompts\"];\nexport const DEFAULT_PROMPT_NAME = \"doc\";\nexport const 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","import fs from \"fs\";\nimport path from \"path\";\nimport { WORKSPACE_ROOT_ENV } from \"../constants\";\n\nlet workspaceRoot = initializeWorkspaceRoot();\nlet userErrorCtor: (new (message: string) => Error) | undefined;\n\nexport class WorkspaceError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"WorkspaceError\";\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\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\nexport async function throwUserError(message: string): Promise<never> {\n  const Ctor = await getUserErrorCtor();\n  throw new Ctor(message);\n}\n\nexport function setWorkspaceRoot(root: string) {\n  workspaceRoot = path.resolve(root);\n}\n\nexport function getWorkspaceRoot(): string {\n  return workspaceRoot;\n}\n\nexport function 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\nexport async 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\nexport function __resetWorkspaceRoot(root: string) {\n  setWorkspaceRoot(root);\n}\n","export const prompts = [] as const;\n","export const resources = [\n  {\n    \"id\": \"decoration.repo\",\n    \"name\": \"decoration repository\",\n    \"description\": \"Source repository\",\n    \"uri\": \"file:///home/tvenceslau/local-workspace/decaf-ts/mcp-server/src/modules/decoration\",\n    \"absolutePath\": \"/home/tvenceslau/local-workspace/decaf-ts/mcp-server/src/modules/decoration\"\n  }\n] as const;\n","export const templates = [\n  {\n    \"name\": \"readme-template\",\n    \"description\": \"README as guidance\",\n    \"uriTemplate\": \"file:///home/tvenceslau/local-workspace/decaf-ts/mcp-server/src/modules/decoration/README.md\",\n    \"mimeType\": \"text/markdown\"\n  }\n] as const;\n","import { z } from \"zod\";\n\nexport const analyzeRepoSchema = z\n  .object({\n    repoPath: z\n      .string()\n      .min(1, \"repoPath is required\")\n      .describe(\n        \"Relative or absolute path to the target repository inside this monorepo, e.g. './decoration'.\"\n      ),\n    includeTests: z\n      .boolean()\n      .default(true)\n      .describe(\n        \"If true, analyze the tests directory (if present) to derive expected behaviors.\"\n      ),\n    includeDocs: z\n      .boolean()\n      .default(true)\n      .describe(\n        \"If true, analyze README.md and docs directories to extract documented features.\"\n      ),\n  })\n  .strict()\n  .describe(\n    \"Analyze a local repository (e.g. ./decoration) to extract APIs, features, tests, and documentation cues.\"\n  );\n\nexport const enumerateCapabilitiesSchema = z\n  .object({\n    repoPath: z\n      .string()\n      .min(1, \"repoPath is required\")\n      .describe(\n        \"Relative or absolute path to the target repository to enumerate developer-facing capabilities.\"\n      ),\n  })\n  .strict()\n  .describe(\n    \"Enumerate the complete set of capabilities a developer is expected to use from the given repository.\"\n  );\n\nexport const planFeatureSchema = z\n  .object({\n    feature: z\n      .string()\n      .min(5, \"feature must describe the goal clearly\")\n      .describe(\n        \"Natural-language description of a developer's requested feature or task to implement using the repository and available MCP tools.\"\n      ),\n    repoPath: z\n      .string()\n      .default(\"./decoration\")\n      .describe(\n        \"Target repository path providing the library to use, e.g. './decoration'.\"\n      ),\n  })\n  .strict()\n  .describe(\n    \"Plan which MCP tools to use and in what sequence to implement a requested feature using the repository.\"\n  );\n\nexport const 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\nexport const 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\nconst OBJECT_TYPES = [\n  \"module\",\n  \"file\",\n  \"class\",\n  \"function\",\n  \"interface\",\n  \"decorator\",\n  \"constant\",\n] as const;\n\nexport const documentObjectSchema = z\n  .object({\n    basePath: z.string().min(1, \"basePath is required\"),\n    objectType: z.enum(OBJECT_TYPES),\n    targetFile: z.string().optional(),\n    includeContent: z.boolean().default(false),\n  })\n  .strict();\n\nexport const coverageTaskSchema = z\n  .object({\n    basePath: z.string().min(1, \"basePath is required\"),\n    coverage: z\n      .number()\n      .min(0)\n      .max(100)\n      .default(90)\n      .describe(\"Target coverage percentage\"),\n    dryRun: z.boolean().default(false),\n  })\n  .strict();\n\nexport const readmeImprovementSchema = z\n  .object({\n    basePath: z.string().min(1, \"basePath is required\"),\n    includeExamples: z.boolean().default(true),\n  })\n  .strict();\n","import fs from \"fs\";\nimport path from \"path\";\nimport { analyzeRepo } from \"./code\";\n\nexport function readFileSafe(\n  filePath: string,\n  encoding: BufferEncoding = \"utf8\"\n): string | undefined {\n  try {\n    return fs.readFileSync(filePath, { encoding });\n  } catch {\n    return undefined;\n  }\n}\n\nexport function listFilesRecursive(\n  root: string,\n  matcher?: (p: string) => boolean\n): string[] {\n  const out: string[] = [];\n  const stack: string[] = [root];\n  while (stack.length) {\n    const cur = stack.pop()!;\n    const stat = fs.statSync(cur);\n    if (stat.isDirectory()) {\n      for (const f of fs.readdirSync(cur)) stack.push(path.join(cur, f));\n    } else if (!matcher || matcher(cur)) {\n      out.push(cur);\n    }\n  }\n  return out.sort();\n}\n\nexport function deriveCapabilities(\n  analysis: ReturnType<typeof analyzeRepo>\n): string[] {\n  const cap = new Set<string>();\n  // heuristics: if decorators like Decoration, flavouredAs, extend, override appear, add capabilities\n  const allDecs = new Set<string>();\n  for (const k of Object.keys(analysis.api)) {\n    for (const d of analysis.api[k].decorators) allDecs.add(d);\n    for (const e of analysis.api[k].exports)\n      if (/Decoration|decorate|Builder|Flavour/i.test(e))\n        cap.add(\"use-decoration-api\");\n  }\n  if ([...allDecs].some((d) => /override|extend/i.test(d)))\n    cap.add(\"override-and-extend-decorations\");\n  if (Object.keys(analysis.tests).length > 0) cap.add(\"validate-with-tests\");\n  if (analysis.readme) cap.add(\"follow-readme-guides\");\n  return [...cap].sort();\n}\n","// Analysis helpers (minimal yet effective, text-based to avoid heavy AST deps)\nimport path from \"path\";\nimport fs from \"fs\";\nimport { listFilesRecursive, readFileSafe } from \"./utils\";\n\nexport function isSourceFile(p: string) {\n  return /\\.(ts|tsx|js|jsx)$/.test(p) && !p.endsWith(\".d.ts\");\n}\nexport function isTestFile(p: string) {\n  return /(\\.test\\.|\\.spec\\.)/.test(p);\n}\n\nexport function extractExports(fileContent: string): string[] {\n  const names = new Set<string>();\n  const exportRe =\n    /(export\\s+(?:default\\s+)?(?:class|function|const|let|var|interface|type|enum)\\s+)([A-Za-z0-9_]+)/g;\n  const namedRe = /export\\s*\\{([^}]+)\\}/g;\n  let m: RegExpExecArray | null;\n  while ((m = exportRe.exec(fileContent))) names.add(m[2]);\n  while ((m = namedRe.exec(fileContent))) {\n    m[1]\n      .split(\",\")\n      .map((s) => s.trim().split(\" as \")[0].trim())\n      .forEach((n) => {\n        if (n) names.add(n);\n      });\n  }\n  return [...names].sort();\n}\n\nexport function extractDecorators(fileContent: string): string[] {\n  const decs = new Set<string>();\n  const decRe = /@([A-Za-z_][A-Za-z0-9_]*)/g;\n  let m: RegExpExecArray | null;\n  while ((m = decRe.exec(fileContent))) decs.add(m[1]);\n  return [...decs].sort();\n}\n\nexport function summarizeReadme(readme?: string) {\n  if (!readme) return undefined;\n  const lines = readme.split(/\\r?\\n/).filter(Boolean);\n  const title =\n    lines.find((l) => /^#\\s+/.test(l))?.replace(/^#\\s+/, \"\") || \"README\";\n  const bullets = lines.filter((l) => /^[-*]\\s+/.test(l)).slice(0, 20);\n  return { title, bullets };\n}\n\nexport function analyzeRepo(root: string) {\n  const src = path.join(root, \"src\");\n  const testDir = path.join(root, \"tests\");\n  const readmePath = path.join(root, \"README.md\");\n  const readme = readFileSafe(readmePath);\n\n  const files = fs.existsSync(src) ? listFilesRecursive(src, isSourceFile) : [];\n  const testFiles = fs.existsSync(testDir)\n    ? listFilesRecursive(testDir, (f) => isSourceFile(f) && isTestFile(f))\n    : [];\n\n  const api: Record<string, { exports: string[]; decorators: string[] }> = {};\n  for (const f of files) {\n    const content = readFileSafe(f) || \"\";\n    api[path.relative(root, f)] = {\n      exports: extractExports(content),\n      decorators: extractDecorators(content),\n    };\n  }\n  const tests: Record<string, { mentions: string[] }> = {};\n  for (const f of testFiles) {\n    const content = readFileSafe(f) || \"\";\n    const mentions = Array.from(\n      new Set([...extractExports(content), ...extractDecorators(content)])\n    ).sort();\n    tests[path.relative(root, f)] = { mentions };\n  }\n  return { files, testFiles, api, tests, readme: summarizeReadme(readme) };\n}\n","import fs from \"fs\";\nimport path from \"path\";\nimport { ContentResult, Tool } from \"fastmcp\";\nimport { applyPatch, createTwoFilesPatch } from \"diff\";\nimport {\n  analyzeRepoSchema,\n  codeChangeSchema,\n  documentCodeSchema,\n  enumerateCapabilitiesSchema,\n  planFeatureSchema,\n} from \"../schemas\";\nimport { analyzeRepo } from \"../code\";\nimport { deriveCapabilities } from \"../utils\";\nimport {\n  getWorkspaceRoot,\n  resolveInWorkspace,\n  throwUserError,\n  WorkspaceError,\n} from \"../workspace\";\nimport {\n  buildDocumentationPayload,\n  DEFAULT_PROMPT_NAME,\n  discoverDocPrompts,\n  selectPrompt,\n} from \"../prompts/prompts\";\nimport type { ApplyCodeChangeArgs, DocumentCodeArgs } from \"../types\";\nimport { generateMcpModuleTool } from \"./generateMcpModule\";\n\nexport function buildAnalyzeRepositoryTool(): Tool<\n  undefined,\n  typeof analyzeRepoSchema\n> {\n  return {\n    name: \"analyze-repository\",\n    description:\n      \"Analyze a local repository's source, tests, and docs to extract exported APIs, decorators, and test mentions.\",\n    parameters: analyzeRepoSchema,\n    execute: async (input) => {\n      let repoRoot = path.resolve(process.cwd(), input.repoPath);\n      if (!fs.existsSync(repoRoot)) {\n        // try resolving from monorepo root (parent of current cwd)\n        const alt = path.resolve(process.cwd(), \"..\", input.repoPath);\n        if (fs.existsSync(alt)) repoRoot = alt;\n      }\n      if (!fs.existsSync(repoRoot)) {\n        // if input was absolute and still not found, try ../<basename>\n        const alt2 = path.resolve(\n          process.cwd(),\n          \"..\",\n          path.basename(input.repoPath)\n        );\n        if (fs.existsSync(alt2)) repoRoot = alt2;\n      }\n      if (!fs.existsSync(repoRoot))\n        throw new Error(`Repository not found at ${repoRoot}`);\n      const result = analyzeRepo(repoRoot);\n      return {\n        content: [{ type: \"text\", text: JSON.stringify(result, null, 2) }],\n      };\n    },\n  };\n}\n\nexport function buildEnumerateCapabilitiesTool(): Tool<\n  undefined,\n  typeof enumerateCapabilitiesSchema\n> {\n  return {\n    name: \"enumerate-capabilities\",\n    description:\n      \"Enumerate developer-facing capabilities of the given repository, inferred from code, tests, and docs.\",\n    parameters: enumerateCapabilitiesSchema,\n    execute: async (input) => {\n      let repoRoot = path.resolve(process.cwd(), input.repoPath);\n      if (!fs.existsSync(repoRoot)) {\n        const alt = path.resolve(process.cwd(), \"..\", input.repoPath);\n        if (fs.existsSync(alt)) repoRoot = alt;\n      }\n      if (!fs.existsSync(repoRoot)) {\n        const alt2 = path.resolve(\n          process.cwd(),\n          \"..\",\n          path.basename(input.repoPath)\n        );\n        if (fs.existsSync(alt2)) repoRoot = alt2;\n      }\n      if (!fs.existsSync(repoRoot))\n        throw new Error(`Repository not found at ${repoRoot}`);\n      const analysis = analyzeRepo(repoRoot);\n      const capabilities = deriveCapabilities(analysis);\n      return {\n        content: [\n          {\n            type: \"text\",\n            text: JSON.stringify(\n              {\n                capabilities,\n                analysisSummary: {\n                  files: analysis.files.length,\n                  testFiles: analysis.testFiles.length,\n                  readme: analysis.readme?.title,\n                },\n              },\n              null,\n              2\n            ),\n          },\n        ],\n      };\n    },\n  };\n}\n\nexport function buildPlanFeatureTool(): Tool<\n  undefined,\n  typeof planFeatureSchema\n> {\n  return {\n    name: \"plan-feature-implementation\",\n    description:\n      \"Given a feature request, select appropriate MCP tools (including existing and new ones) and produce an execution plan.\",\n    parameters: planFeatureSchema,\n    execute: async (input) => {\n      const steps: Array<{\n        step: number;\n        action: string;\n        tool?: string;\n        arguments?: Record<string, any>;\n        rationale: string;\n      }> = [];\n      let i = 1;\n      steps.push({\n        step: i++,\n        action: \"Analyze repository to enumerate APIs and decorators\",\n        tool: \"analyze-repository\",\n        arguments: { repoPath: input.repoPath },\n        rationale: \"Understand available building blocks.\",\n      });\n      steps.push({\n        step: i++,\n        action: \"List capabilities expected for developers\",\n        tool: \"enumerate-capabilities\",\n        arguments: { repoPath: input.repoPath },\n        rationale: \"Align the plan with supported capabilities.\",\n      });\n      // Suggest existing generic tools from mcp-module\n      steps.push({\n        step: i++,\n        action:\n          \"Select documentation prompt and gather relevant source file(s)\",\n        tool: \"document-code\",\n        arguments: { filePath: \"<target-file>\" },\n        rationale: \"Provide context and instructions for changes.\",\n      });\n      steps.push({\n        step: i++,\n        action: \"Apply code changes using unified diff patch\",\n        tool: \"apply-code-change\",\n        arguments: {\n          filePath: \"<target-file>\",\n          patch: \"<unified-diff>\",\n          dryRun: true,\n        },\n        rationale: \"Validate changes safely before committing.\",\n      });\n      steps.push({\n        step: i++,\n        action: \"Commit code changes\",\n        tool: \"apply-code-change\",\n        arguments: {\n          filePath: \"<target-file>\",\n          patch: \"<unified-diff>\",\n          dryRun: false,\n        },\n        rationale: \"Persist the update.\",\n      });\n      // If decoration-related terms present, suggest decorator tools\n      if (/decorat|flavour|override|extend|builder/i.test(input.feature)) {\n        steps.unshift({\n          step: 0,\n          action: \"Use decorator tooling to insert/remove/modify decorators\",\n          tool: \"decorator-tools\",\n          arguments: { action: \"help\" },\n          rationale: \"Leverage specialized utilities for decoration patterns.\",\n        });\n        steps.forEach((s, idx) => (s.step = idx + 1));\n      }\n      return {\n        content: [\n          {\n            type: \"text\",\n            text: JSON.stringify(\n              {\n                plan: steps,\n                notes:\n                  \"Replace placeholder arguments like <target-file> and <unified-diff> based on the analysis output.\",\n              },\n              null,\n              2\n            ),\n          },\n        ],\n      };\n    },\n  };\n}\n\nexport const 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\nexport const 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\ntype AnyTool = Tool<undefined, any>;\n\nconst analyticTools: AnyTool[] = [\n  buildAnalyzeRepositoryTool(),\n  buildEnumerateCapabilitiesTool(),\n  buildPlanFeatureTool(),\n];\n\nexport const toolList: AnyTool[] = [\n  ...analyticTools,\n  documentCodeTool,\n  applyCodeChangeTool,\n];\n","import type { Tool } from 'fastmcp';\nimport { buildAnalyzeRepositoryTool, buildEnumerateCapabilitiesTool, buildPlanFeatureTool } from '../../../mcp/tools/tools';\nexport const tools = [\n  { id: 'decoration.analyze', title: 'Analyze decoration', description: 'Analyze the target repository', tool: buildAnalyzeRepositoryTool() },\n  { id: 'decoration.enumerate', title: 'Enumerate capabilities for decoration', description: 'Enumerate capabilities', tool: buildEnumerateCapabilitiesTool() },\n  { id: 'decoration.plan', title: 'Plan features for decoration', description: 'Plan feature implementation', tool: buildPlanFeatureTool() },\n] as const;\n","import { prompts } from './prompts';\nimport { resources } from './resources';\nimport { templates } from './templates';\nimport { tools } from './tools';\nexport { prompts } from './prompts';\nexport { resources } from './resources';\nexport { templates } from './templates';\nexport { tools } from './tools';\nexport const modulePackage = { name: 'decoration', prompts, resources, templates, tools } as const;\n","import type { PromptAsset } from \"../../../types\";\n\nexport const prompts: PromptAsset[] = [\n  {\n    id: \"mcp.prompt.module-catalog\",\n    title: \"Decaf MCP Module Catalog\",\n    description: \"Summarizes the modules contributing prompts/resources/templates/tools to FASTMCP.\",\n    load: async () =>\n      \"Use the module catalog tool to enumerate available module assets before fulfilling assistant requests.\",\n  },\n];\n","import type { ResourceAsset } from \"../../../types\";\n\nexport const resources: ResourceAsset[] = [\n  {\n    id: \"mcp.resource.registry-overview\",\n    title: \"Module Registry Overview\",\n    description:\n      \"Explains how the ModuleRegistry aggregates module exports into FASTMCP catalogs.\",\n    uri: \"decaf://mcp/module-registry\",\n    mimeType: \"text/markdown\",\n    load: async () => ({\n      content: [\n        {\n          type: \"text\",\n          text: [\n            \"# Module Registry\",\n            \"\",\n            \"The Decaf MCP server aggregates prompts, resources, templates, and tools from every module under src/modules.\",\n            \"Validators ensure each module contains the canonical folder layout before the registry loads it.\",\n          ].join(\"\\n\"),\n          mimeType: \"text/markdown\",\n        },\n      ],\n    }),\n  },\n];\n\n","import type { TemplateAsset } from \"../../../types\";\n\nexport const templates: TemplateAsset[] = [\n  {\n    id: \"mcp.template.module-readme\",\n    title: \"Module README Template\",\n    description: \"Guides maintainers through documenting a new MCP-aware module.\",\n    content: `# {{moduleName}} Module\n\n## Purpose\nDescribe why this module exists and how assistants should use it.\n\n## Assets\n- Prompts: {{promptSummary}}\n- Resources: {{resourceSummary}}\n- Templates: {{templateSummary}}\n- Tools: {{toolSummary}}\n\n## Validation\nExplain what needs to happen when this module changes (tests, docs, etc.).`,\n    placeholders: [\n      \"moduleName\",\n      \"promptSummary\",\n      \"resourceSummary\",\n      \"templateSummary\",\n      \"toolSummary\",\n    ],\n  },\n];\n","const describeModulesTool: any = {\n  name: \"describe-modules\",\n  description:\n    \"Summarize the purpose of Decaf MCP modules for assistant operators.\",\n  // Minimal execute implementation to return a text result\n  execute: async (): Promise<string> =>\n    \"Modules contribute prompts, resources, templates, and tools that the registry exposes to FASTMCP clients.\",\n};\n\nexport const tools = [\n  {\n    id: \"mcp.tool.describe-modules\",\n    title: \"Describe MCP Modules\",\n    description: \"Explains how module exports feed into the FASTMCP server.\",\n    tool: describeModulesTool,\n  },\n];\n","import type { ModuleExportPackage } from \"../../types\";\nimport { prompts } from \"./prompts\";\nimport { resources } from \"./resources\";\nimport { templates } from \"./templates\";\nimport { tools } from \"./tools\";\n\nexport { prompts } from \"./prompts\";\nexport { resources } from \"./resources\";\nexport { templates } from \"./templates\";\nexport { tools } from \"./tools\";\n\nexport const modulePackage: ModuleExportPackage = {\n  name: \"mcp\",\n  prompts,\n  resources,\n  templates,\n  tools,\n};\n","export const prompts = [\n  {\n    id: \"_template.readme\",\n    title: \"Template README\",\n    description: \"A README prompt for module template\",\n    load: () => \"Template prompt content\",\n  },\n] as const;\n","export const resources = [\n  {\n    id: \"_template.repo\",\n    name: \"template repo\",\n    description: \"Template resource\",\n    uri: \"file:///tmp/template\",\n  },\n] as const;\n","export const templates = [\n  {\n    id: \"_template.readme\",\n    name: \"template-readme\",\n    description: \"README guidance\",\n    uriTemplate: \"file:///tmp/template/README.md\",\n    mimeType: \"text/markdown\",\n  },\n] as const;\n","const placeholderTool: any = {\n  name: \"_template.tool\",\n  description: \"A placeholder tool\",\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  execute: async (_input: any, _context: any): Promise<string> => \"ok\",\n};\n\nexport const tools = [\n  {\n    id: \"_template.tool\",\n    title: \"template tool\",\n    description: \"A placeholder tool\",\n    tool: placeholderTool,\n  },\n] as const;\n","import { prompts } from \"./prompts\";\nimport { resources } from \"./resources\";\nimport { templates } from \"./templates\";\nimport { tools } from \"./tools\";\nexport { prompts } from \"./prompts\";\nexport { resources } from \"./resources\";\nexport { templates } from \"./templates\";\nexport { tools } from \"./tools\";\nexport const modulePackage = {\n  name: \"_template\",\n  prompts,\n  resources,\n  templates,\n  tools,\n} as const;\n","import type { ModuleExportPackage } from \"../types\";\nimport { modulePackage as decorationModule } from \"./decoration\";\nimport { modulePackage as mcpModule } from \"./mcp\";\nimport { modulePackage as templateModule } from \"./_template\";\n\n// modulePackage objects may be declared with readonly arrays (as const). Cast to the mutable type expected by runtime APIs.\nexport const modulePackages: ModuleExportPackage[] = [\n  decorationModule as unknown as ModuleExportPackage,\n  mcpModule as unknown as ModuleExportPackage,\n  templateModule as unknown as ModuleExportPackage,\n];\n","import type {\n  ModuleExportPackage,\n  PromptAsset,\n  ResourceAsset,\n  TemplateAsset,\n  ToolAsset,\n} from \"../types\";\nimport { modulePackages } from \"../modules\";\n\ntype AssetKey = \"prompts\" | \"resources\" | \"templates\" | \"tools\";\n\nexport class ModuleRegistry {\n  // Defensive default: modulePackages may be undefined during circular imports\n  constructor(\n    private readonly packages: ModuleExportPackage[] = Array.isArray(\n      modulePackages\n    )\n      ? (modulePackages as ModuleExportPackage[])\n      : []\n  ) {}\n\n  listPackages(): ModuleExportPackage[] {\n    return this.packages;\n  }\n\n  listPrompts(): PromptAsset[] {\n    return this.collectAssets(\"prompts\");\n  }\n\n  listResources(): ResourceAsset[] {\n    return this.collectAssets(\"resources\");\n  }\n\n  listTemplates(): TemplateAsset[] {\n    return this.collectAssets(\"templates\");\n  }\n\n  listTools(): ToolAsset[] {\n    return this.collectAssets(\"tools\");\n  }\n\n  private collectAssets<\n    T extends PromptAsset | ResourceAsset | TemplateAsset | ToolAsset,\n  >(key: AssetKey): T[] {\n    const seen = new Map<string, string>();\n    const aggregated: T[] = [];\n\n    for (const pkg of this.packages) {\n      if (pkg.status === \"disabled\") continue;\n      for (const asset of pkg[key] as T[]) {\n        // asset.name is not guaranteed on all asset types; use type-safe fallback\n        const maybeName = (asset as any).name as string | undefined;\n        const assetKey =\n          (asset && (asset.id ?? maybeName)) || JSON.stringify(asset);\n        if (seen.has(assetKey)) {\n          const conflict = seen.get(assetKey);\n          throw new Error(\n            `Duplicate ${key} id '${assetKey}' from modules ${conflict} and ${pkg.name}`\n          );\n        }\n        seen.set(assetKey, pkg.name);\n        aggregated.push({ ...asset, provenance: pkg.name });\n      }\n    }\n\n    return aggregated;\n  }\n}\n\nexport const moduleRegistry = new ModuleRegistry();\n","import fs from \"fs\";\nimport path from \"path\";\nimport type { ContentResult, InputPrompt } from \"fastmcp\";\nimport {\n  CLIENT_INTEGRATIONS,\n  DEFAULT_PROMPT_NAME,\n  PROMPT_DIRECTORIES,\n} from \"../../constants\";\nimport type { DocPrompt } from \"../types\";\nimport { getWorkspaceRoot } from \"../workspace\";\nimport type { PromptAsset } from \"../../types\";\nimport { moduleRegistry } from \"../moduleRegistry\";\n\nexport const prompts: InputPrompt<undefined>[] = [];\n\nconst OBJECT_PROMPT_DEPENDENCIES: Record<string, readonly string[]> = {\n  module: [\"doc\", \"module\"],\n  file: [\"doc\", \"file\"],\n  class: [\"doc\", \"class\"],\n  function: [\"doc\", \"function\"],\n  interface: [\"doc\", \"interface\"],\n  decorator: [\"doc\", \"decorator\"],\n  constant: [\"doc\", \"constant\"],\n  \"bulk-docs\": [\"bulk-docs\"],\n  \"bulk-tests\": [\"bulk-tests\"],\n  \"update-readme\": [\"update-readme\"],\n  \"repo-setup\": [\"repo-setup\"],\n  \"release-notes\": [\"release-notes\"],\n  \"mcp-module\": [\"mcp-module\"],\n};\n\nexport function getObjectPromptDependencies(): Record<\n  string,\n  readonly string[]\n> {\n  return OBJECT_PROMPT_DEPENDENCIES;\n}\n\nexport function buildPrompts(repoPath: string): InputPrompt<undefined>[] {\n  return [\n    {\n      name: \"decoration-overview\",\n      description:\n        \"High-level guidance on using the decoration library: key exports, decorators, and common workflows.\",\n      load: async () =>\n        `You are assisting with the Decaf.ts decoration module located at ${repoPath}. Prefer using exported builders and decorators over ad-hoc patterns.\\n\\nProvide a concise, actionable overview of how to use the decoration APIs for extending and overriding behaviors.`,\n    },\n  ];\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 summarizePromptContent(\n  prompt: DocPrompt,\n  headingPrefix: string\n): string {\n  return [`## ${headingPrefix}`, \"\", prompt.content.trim()].join(\"\\n\");\n}\n\nexport function buildObjectPrompts(): InputPrompt<undefined>[] {\n  const root = getWorkspaceRoot();\n  const discovered = discoverDocPrompts(root);\n  const promptByName = new Map<string, DocPrompt>();\n  for (const prompt of discovered) {\n    promptByName.set(prompt.name, prompt);\n  }\n\n  const outputs: InputPrompt<undefined>[] = [];\n  for (const [objectType, dependencies] of Object.entries(\n    OBJECT_PROMPT_DEPENDENCIES\n  )) {\n    const existing = dependencies\n      .map((name) => promptByName.get(name))\n      .filter((prompt): prompt is DocPrompt => Boolean(prompt));\n    if (!existing.length) continue;\n\n    outputs.push({\n      name: `codex/${objectType}`,\n      description: `Guidance derived from .codex prompts for ${objectType} tasks.`,\n      load: async () => {\n        const sections = existing.map((prompt) =>\n          summarizePromptContent(prompt, toTitleCase(prompt.name))\n        );\n        return [`# Codex guidance for ${objectType}`, \"\", ...sections].join(\n          \"\\n\"\n        );\n      },\n    });\n  }\n\n  return outputs.sort((a, b) => a.name.localeCompare(b.name));\n}\n\nfunction toInputPrompt(asset: PromptAsset): InputPrompt<undefined> {\n  const provenance = asset.provenance ? ` (module: ${asset.provenance})` : \"\";\n  return {\n    name: asset.id,\n    description: `${asset.description ?? asset.title}${provenance}`,\n    load: async () => asset.load(),\n  };\n}\n\nfunction buildModulePrompts(): InputPrompt<undefined>[] {\n  return moduleRegistry.listPrompts().map(toInputPrompt);\n}\n\nexport function refreshPrompts(repoPath?: string): InputPrompt<undefined>[] {\n  const docPrompts = buildDocPrompts();\n  const objectPrompts = buildObjectPrompts();\n  const repoPrompts = repoPath ? buildPrompts(repoPath) : [];\n  const modulePrompts = buildModulePrompts();\n  prompts.splice(\n    0,\n    prompts.length,\n    ...docPrompts,\n    ...objectPrompts,\n    ...repoPrompts,\n    ...modulePrompts\n  );\n  return prompts;\n}\n\nexport function discoverDocPrompts(root: string): DocPrompt[] {\n  const discovered: DocPrompt[] = [];\n\n  for (const directory of PROMPT_DIRECTORIES) {\n    const promptDir = path.join(root, directory);\n    // debug logging to help tests diagnose prompt discovery\n\n    console.debug(\"[discoverDocPrompts] checking\", promptDir);\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\nexport function selectPrompt(\n  promptList: DocPrompt[],\n  requestedName: string\n): DocPrompt {\n  const direct = promptList.find((prompt) => prompt.name === requestedName);\n  if (direct) return direct;\n\n  const fallback = promptList.find(\n    (prompt) => prompt.name === DEFAULT_PROMPT_NAME\n  );\n  if (fallback) return fallback;\n\n  if (!promptList.length) {\n    throw new Error(\"No documentation prompts available\");\n  }\n\n  return promptList[0];\n}\n\nexport function 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 { DEFAULT_PROMPT_NAME };\nexport type { DocPrompt };\n","import type { InputPrompt } from \"fastmcp\";\nimport { prompts, refreshPrompts } from \"./prompts\";\n\nexport * from \"./prompts\";\n\nexport const promptList: InputPrompt<undefined>[] = prompts;\n\nexport function loadPrompts(repoPath?: string): InputPrompt<undefined>[] {\n  return refreshPrompts(repoPath);\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 { spawnSync } from \"child_process\";\nimport type { ContentResult, Tool } from \"fastmcp\";\nimport {\n  documentObjectSchema,\n  coverageTaskSchema,\n  readmeImprovementSchema,\n} from \"../schemas\";\nimport {\n  DocumentObjectArgs,\n  CoverageTaskArgs,\n  ReadmeImprovementArgs,\n} from \"../types\";\nimport {\n  getWorkspaceRoot,\n  resolveInWorkspace,\n  throwUserError,\n  WorkspaceError,\n} from \"../workspace\";\nimport {\n  buildObjectPrompts,\n  discoverDocPrompts,\n  getObjectPromptDependencies,\n} from \"../prompts/prompts\";\nimport type { DocPrompt } from \"../types\";\nimport { listFilesRecursive, readFileSafe } from \"../utils\";\nimport { analyzeRepo, isSourceFile, isTestFile } from \"../code\";\n\ntype PromptSection = {\n  name: string;\n  title: string;\n  description: string;\n  content: string;\n  absolutePath?: string;\n};\n\nfunction relativeFiles(root: string, files: string[]): string[] {\n  return files.map((file) => path.relative(root, file)).sort();\n}\n\nfunction collectPromptSections(names: readonly string[]): PromptSection[] {\n  const root = getWorkspaceRoot();\n  const promptIndex = new Map<string, DocPrompt>(\n    discoverDocPrompts(root).map((prompt) => [prompt.name, prompt])\n  );\n  return names\n    .map((name) => promptIndex.get(name))\n    .filter((prompt): prompt is DocPrompt => Boolean(prompt))\n    .map((prompt) => ({\n      name: prompt.name,\n      title: prompt.title,\n      description: prompt.description,\n      content: prompt.content,\n      absolutePath: prompt.absolutePath,\n    }));\n}\n\nfunction parseTaskLines(content: string): string[] {\n  return content\n    .split(/\\r?\\n/)\n    .map((line) => line.trim())\n    .filter((line) => /^task\\s+\\d+/i.test(line));\n}\n\nfunction computeCoverageFromFinal(coveragePath: string) {\n  const payload = JSON.parse(fs.readFileSync(coveragePath, \"utf8\")) as Record<\n    string,\n    {\n      s: Record<string, number>;\n      f: Record<string, number>;\n      b: Record<string, number | number[]>;\n    }\n  >;\n\n  const totals = {\n    statements: { covered: 0, total: 0 },\n    functions: { covered: 0, total: 0 },\n    branches: { covered: 0, total: 0 },\n  };\n\n  const files = Object.entries(payload).map(([filePath, info]) => {\n    const statementCounts = Object.values(info.s);\n    const functionCounts = Object.values(info.f);\n    const branchCounts = Object.values(info.b).flatMap((value) =>\n      Array.isArray(value) ? value : [value]\n    );\n\n    const statementTotal = statementCounts.length;\n    const functionTotal = functionCounts.length;\n    const branchTotal = branchCounts.length;\n\n    const statementCovered = statementCounts.filter(\n      (count) => count > 0\n    ).length;\n    const functionCovered = functionCounts.filter((count) => count > 0).length;\n    const branchCovered = branchCounts.filter((count) => count > 0).length;\n\n    totals.statements.covered += statementCovered;\n    totals.statements.total += statementTotal;\n    totals.functions.covered += functionCovered;\n    totals.functions.total += functionTotal;\n    totals.branches.covered += branchCovered;\n    totals.branches.total += branchTotal;\n\n    const pct = (covered: number, total: number) =>\n      total === 0 ? 100 : Number(((covered / total) * 100).toFixed(2));\n\n    return {\n      path: filePath,\n      statements: pct(statementCovered, statementTotal),\n      functions: pct(functionCovered, functionTotal),\n      branches: pct(branchCovered, branchTotal),\n    };\n  });\n\n  const pct = (covered: number, total: number) =>\n    total === 0 ? 100 : Number(((covered / total) * 100).toFixed(2));\n\n  return {\n    totals: {\n      statements: {\n        ...totals.statements,\n        pct: pct(totals.statements.covered, totals.statements.total),\n      },\n      functions: {\n        ...totals.functions,\n        pct: pct(totals.functions.covered, totals.functions.total),\n      },\n      branches: {\n        ...totals.branches,\n        pct: pct(totals.branches.covered, totals.branches.total),\n      },\n    },\n    files,\n  };\n}\n\nfunction normalizePromptSections(sections: PromptSection[]) {\n  return sections.map((section) => ({\n    name: section.name,\n    title: section.title,\n    tasks: parseTaskLines(section.content),\n    content: section.content,\n  }));\n}\n\nasync function resolveRepoRoot(basePath: string) {\n  const root = getWorkspaceRoot();\n  try {\n    return resolveInWorkspace(root, basePath);\n  } catch (error) {\n    if (error instanceof WorkspaceError) {\n      await throwUserError(error.message);\n    }\n    throw error;\n  }\n}\n\nexport const documentObjectTool: Tool<undefined, typeof documentObjectSchema> =\n  {\n    name: \"document-object\",\n    description:\n      \"Create a documentation plan for a specific object type using .codex prompts and repository analysis.\",\n    parameters: documentObjectSchema,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    execute: async (input, _context): Promise<ContentResult> => {\n      const args = documentObjectSchema.parse(input as DocumentObjectArgs);\n      const repoRoot = await resolveRepoRoot(args.basePath);\n\n      const dependencies = getObjectPromptDependencies()[args.objectType] ?? [];\n      if (!dependencies.length) {\n        await throwUserError(\n          `No prompt guidance configured for object type ${args.objectType}`\n        );\n      }\n\n      const sections = normalizePromptSections(\n        collectPromptSections(dependencies)\n      );\n\n      const srcDir = path.join(repoRoot, \"src\");\n      const testDir = path.join(repoRoot, \"tests\");\n\n      const sourceFiles = fs.existsSync(srcDir)\n        ? listFilesRecursive(srcDir, isSourceFile)\n        : [];\n      const testFiles = fs.existsSync(testDir)\n        ? listFilesRecursive(\n            testDir,\n            (file) => isSourceFile(file) && isTestFile(file)\n          )\n        : [];\n\n      let targetFileContent: string | undefined;\n      if (args.targetFile) {\n        try {\n          const absolute = resolveInWorkspace(repoRoot, args.targetFile);\n          targetFileContent = readFileSafe(absolute) ?? undefined;\n        } catch (error) {\n          if (error instanceof WorkspaceError) {\n            await throwUserError(error.message);\n          }\n          throw error;\n        }\n      }\n\n      const payload = {\n        basePath: path.relative(getWorkspaceRoot(), repoRoot) || \".\",\n        objectType: args.objectType,\n        targetFile: args.targetFile,\n        guidance: sections,\n        files: {\n          source: relativeFiles(repoRoot, sourceFiles),\n          tests: relativeFiles(repoRoot, testFiles),\n        },\n        targetFileContent: args.includeContent ? targetFileContent : undefined,\n      };\n\n      return {\n        content: [\n          {\n            type: \"text\",\n            text: JSON.stringify(payload, null, 2),\n          },\n        ],\n      } satisfies ContentResult;\n    },\n  };\n\nexport const coverageEnforcerTool: Tool<undefined, typeof coverageTaskSchema> =\n  {\n    name: \"ensure-test-coverage\",\n    description:\n      \"Run the configured coverage command and report whether the target percentage is met, highlighting weak files.\",\n    parameters: coverageTaskSchema,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    execute: async (input, _context): Promise<ContentResult> => {\n      const args = coverageTaskSchema.parse(input as CoverageTaskArgs);\n      const repoRoot = await resolveRepoRoot(args.basePath);\n\n      if (!args.dryRun) {\n        const env = {\n          ...process.env,\n          USE_WATCHMAN: \"false\",\n          WATCHMAN_DISABLE: \"1\",\n          JEST_DISABLE_WATCHMAN: \"1\",\n        };\n        const result = spawnSync(\n          \"npm\",\n          [\"run\", \"coverage\", \"--\", \"--watchman=false\", \"--runInBand\"],\n          { cwd: repoRoot, env, encoding: \"utf8\" }\n        );\n\n        if (result.status !== 0) {\n          const message =\n            result.stderr || result.stdout || \"Coverage command failed\";\n          await throwUserError(message.trim());\n        }\n      }\n\n      const coveragePath = path.join(\n        repoRoot,\n        \"workdocs\",\n        \"reports\",\n        \"coverage\",\n        \"coverage-final.json\"\n      );\n\n      if (!fs.existsSync(coveragePath)) {\n        await throwUserError(\n          `Coverage report not found at ${path.relative(repoRoot, coveragePath)}`\n        );\n      }\n\n      const summary = computeCoverageFromFinal(coveragePath);\n      const meetsThreshold =\n        summary.totals.statements.pct >= args.coverage &&\n        summary.totals.functions.pct >= args.coverage &&\n        summary.totals.branches.pct >= args.coverage;\n\n      const weakest = [...summary.files]\n        .sort((a, b) => a.statements - b.statements)\n        .slice(0, 10);\n\n      const guidance = normalizePromptSections(\n        collectPromptSections([\"bulk-tests\"])\n      );\n\n      const payload = {\n        basePath: path.relative(getWorkspaceRoot(), repoRoot) || \".\",\n        target: args.coverage,\n        meetsThreshold,\n        totals: summary.totals,\n        weakest,\n        guidance,\n      };\n\n      return {\n        content: [\n          {\n            type: \"text\",\n            text: JSON.stringify(payload, null, 2),\n          },\n        ],\n      } satisfies ContentResult;\n    },\n  };\n\nexport const readmeImprovementTool: Tool<\n  undefined,\n  typeof readmeImprovementSchema\n> = {\n  name: \"improve-readme\",\n  description:\n    \"Summarize required steps to refresh README and workdocs content using .codex guidance and repository analysis.\",\n  parameters: readmeImprovementSchema,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  execute: async (input, _context): Promise<ContentResult> => {\n    const args = readmeImprovementSchema.parse(input as ReadmeImprovementArgs);\n    const repoRoot = await resolveRepoRoot(args.basePath);\n\n    const analysis = analyzeRepo(repoRoot);\n    const modules = analysis.files\n      .filter((file) => /index\\.ts$/.test(file))\n      .map((file) => path.relative(repoRoot, file));\n\n    const promptSections = normalizePromptSections(\n      collectPromptSections([\"update-readme\", \"doc\", \"module\"])\n    );\n\n    const testExamples = Object.keys(analysis.tests ?? {});\n    const examples = args.includeExamples ? testExamples.slice(0, 20) : [];\n\n    const payload = {\n      basePath: path.relative(getWorkspaceRoot(), repoRoot) || \".\",\n      summary: {\n        modules,\n        totalSourceFiles: analysis.files.length,\n        totalTestFiles: analysis.testFiles.length,\n        hasReadme: Boolean(analysis.readme),\n      },\n      guidance: promptSections,\n      suggestedExamples: examples,\n    };\n\n    return {\n      content: [\n        {\n          type: \"text\",\n          text: JSON.stringify(payload, null, 2),\n        },\n      ],\n    } satisfies ContentResult;\n  },\n};\n","import fs from \"fs\";\nimport path from \"path\";\n\nexport type ScaffoldResult = {\n  modulePath: string;\n  createdFiles: string[];\n};\n\nconst DEFAULT_PLACEHOLDERS = {\n  prompts: `export const promptList = [\n  {\n    id: \"example-prompt\",\n    title: \"Example prompt\",\n    description: \"A placeholder prompt created by scaffoldModule\",\n    content: \"Describe the task for the assistant...\",\n    absolutePath: __filename,\n  },\n] as const;\n`,\n  resources: `export const resources = [\n  {\n    id: \"example-resource\",\n    name: \"Example Resource\",\n    description: \"A placeholder resource created by scaffoldModule\",\n    uri: \"file://placeholder\",\n    absolutePath: __filename,\n  },\n] as const;\n`,\n  templates: `export const templates = [\n  {\n    name: \"example-template\",\n    description: \"A placeholder template created by scaffoldModule\",\n    uriTemplate: \"file://template/{path}\",\n    mimeType: \"text/plain\",\n  },\n] as const;\n`,\n  tools: `export const toolList = [\n  {\n    id: \"example-tool\",\n    name: \"example-tool\",\n    description: \"A placeholder tool created by scaffoldModule\",\n    run: async () => ({ result: \"placeholder\" }),\n  },\n] as const;\n`,\n};\n\n/**\n * Create a module scaffold under repoRoot/src/modules/<moduleName>\n * Returns created files list.\n */\nexport function scaffoldModule(\n  repoRoot: string,\n  moduleName: string\n): ScaffoldResult {\n  if (!repoRoot) throw new Error(\"repoRoot is required\");\n  if (!moduleName) throw new Error(\"moduleName is required\");\n\n  const modulePath = path.join(repoRoot, \"src\", \"modules\", moduleName);\n  const createdFiles: string[] = [];\n\n  const subfolders = [\"prompts\", \"resources\", \"templates\", \"tools\"];\n\n  for (const folder of subfolders) {\n    const folderPath = path.join(modulePath, folder);\n    fs.mkdirSync(folderPath, { recursive: true });\n    const indexPath = path.join(folderPath, \"index.ts\");\n    // if file exists, skip writing\n    if (!fs.existsSync(indexPath)) {\n      // insert __filename for absolutePath in placeholders\n      const content = DEFAULT_PLACEHOLDERS[\n        folder as keyof typeof DEFAULT_PLACEHOLDERS\n      ].replace(/__filename/g, JSON.stringify(indexPath));\n      fs.writeFileSync(indexPath, content, { encoding: \"utf8\" });\n      createdFiles.push(indexPath);\n    }\n  }\n\n  return { modulePath, createdFiles };\n}\n\n// CLI support when required directly via ts-node registration\nif (require.main === module) {\n  const [, , moduleName] = process.argv;\n  if (!moduleName) {\n    console.error(\"Usage: scaffold-module <module-name>\");\n    process.exit(1);\n  }\n  try {\n    const res = scaffoldModule(process.cwd(), moduleName);\n    console.log(\"Scaffolded module:\", res.modulePath);\n    for (const f of res.createdFiles) console.log(\"  created:\", f);\n    process.exit(0);\n  } catch (err: any) {\n    console.error(err && err.message ? err.message : err);\n    process.exit(2);\n  }\n}\n","// New tool: generate-mcp-module\nimport fs from \"fs\";\nimport path from \"path\";\nimport type { Tool } from \"fastmcp\";\nimport { z } from \"zod\";\nimport { getWorkspaceRoot } from \"../workspace\";\nimport { analyzeRepo } from \"../code\";\nimport { scaffoldModule } from \"../validation/scaffoldModule\";\n\nconst generateSchema = z.object({\n  repoPath: z.string().optional().default(\".\"),\n  moduleName: z.string().optional(),\n  includeDocs: z.boolean().default(true),\n});\n\ntype GenerateArgs = z.infer<typeof generateSchema>;\n\nexport const generateMcpModuleTool: Tool<undefined, typeof generateSchema> = {\n  name: \"generate-mcp-module\",\n  description:\n    \"Generate a minimal MCP module under src/modules/<name> by analyzing a target repository and exporting prompts, resources, templates and tools.\",\n  parameters: generateSchema,\n  execute: async (input) => {\n    const args = generateSchema.parse(input as any);\n    const root = getWorkspaceRoot();\n    let repoRoot = path.resolve(process.cwd(), args.repoPath || \".\");\n    if (!fs.existsSync(repoRoot)) {\n      const alt = path.resolve(process.cwd(), \"..\", args.repoPath);\n      if (fs.existsSync(alt)) repoRoot = alt;\n    }\n    if (!fs.existsSync(repoRoot)) {\n      const alt2 = path.resolve(\n        process.cwd(),\n        \"..\",\n        path.basename(args.repoPath)\n      );\n      if (fs.existsSync(alt2)) repoRoot = alt2;\n    }\n    if (!fs.existsSync(repoRoot))\n      throw new Error(`Repository not found at ${repoRoot}`);\n\n    const analysis = analyzeRepo(repoRoot);\n    const inferredName =\n      args.moduleName ?? path.basename(path.resolve(repoRoot));\n    const moduleRoot = path.join(root, \"src\", \"modules\", inferredName);\n\n    // Use existing scaffold to create folders\n    scaffoldModule(root, inferredName);\n\n    // populate prompts: copy markdown prompts from README.md and docs/\n    const promptsDir = path.join(moduleRoot, \"prompts\");\n    const resourcesDir = path.join(moduleRoot, \"resources\");\n    const templatesDir = path.join(moduleRoot, \"templates\");\n    const toolsDir = path.join(moduleRoot, \"tools\");\n\n    // helper to write an index.ts that exports arrays\n    function writeIndex(dir: string, varName: string, items: string) {\n      const p = path.join(dir, \"index.ts\");\n      const content = `export const ${varName} = ${items} as const;\\n`;\n      fs.writeFileSync(p, content, { encoding: \"utf8\" });\n    }\n\n    // Prompts: create a simple prompt from README and any .md in docs\n    const promptAssets: any[] = [];\n    if (args.includeDocs) {\n      const readme = path.join(repoRoot, \"README.md\");\n      if (fs.existsSync(readme)) {\n        const content = fs.readFileSync(readme, \"utf8\");\n        const id = \"readme\";\n        const promptPath = path.join(promptsDir, `${id}.md`);\n        fs.writeFileSync(promptPath, content, { encoding: \"utf8\" });\n        promptAssets.push({\n          id,\n          title: \"README\",\n          description: \"Repository README\",\n          absolutePath: promptPath,\n          load: () => content,\n        });\n      }\n      const docsDir = path.join(repoRoot, \"docs\");\n      if (fs.existsSync(docsDir) && fs.statSync(docsDir).isDirectory()) {\n        for (const f of fs.readdirSync(docsDir)) {\n          if (!f.endsWith(\".md\")) continue;\n          const content = fs.readFileSync(path.join(docsDir, f), \"utf8\");\n          const id = path.parse(f).name;\n          const promptPath = path.join(promptsDir, `${id}.md`);\n          fs.writeFileSync(promptPath, content, { encoding: \"utf8\" });\n          promptAssets.push({\n            id,\n            title: id,\n            description: content.split(/\\r?\\n/)[0] || \"\",\n            absolutePath: promptPath,\n            load: () => content,\n          });\n        }\n      }\n    }\n\n    writeIndex(promptsDir, \"prompts\", JSON.stringify(promptAssets, null, 2));\n\n    // Resources: reference the repo root and docs\n    const resourceAssets = [\n      {\n        id: `${inferredName}.repo`,\n        name: `${inferredName} repository`,\n        description: \"Source repository\",\n        uri: `file://${repoRoot}`,\n        absolutePath: repoRoot,\n      },\n    ];\n    writeIndex(\n      resourcesDir,\n      \"resources\",\n      JSON.stringify(resourceAssets, null, 2)\n    );\n\n    // Templates: create a placeholder template that references README\n    const templateAssets = [\n      {\n        name: \"readme-template\",\n        description: \"README as guidance\",\n        uriTemplate: `file://${path.join(repoRoot, \"README.md\")}`,\n        mimeType: \"text/markdown\",\n      },\n    ];\n    writeIndex(\n      templatesDir,\n      \"templates\",\n      JSON.stringify(templateAssets, null, 2)\n    );\n\n    // Tools: create a wrapper tool that exposes analyze/enumerate for the module\n    const toolIndexPath = path.join(toolsDir, \"index.ts\");\n    const toolContent = `import type { Tool } from 'fastmcp';\\nimport { buildAnalyzeRepositoryTool, buildEnumerateCapabilitiesTool, buildPlanFeatureTool } from '../../../mcp/tools/tools';\\nexport const tools = [\\n  { id: '${inferredName}.analyze', title: 'Analyze ${inferredName}', description: 'Analyze the target repository', tool: buildAnalyzeRepositoryTool() },\\n  { id: '${inferredName}.enumerate', title: 'Enumerate capabilities for ${inferredName}', description: 'Enumerate capabilities', tool: buildEnumerateCapabilitiesTool() },\\n  { id: '${inferredName}.plan', title: 'Plan features for ${inferredName}', description: 'Plan feature implementation', tool: buildPlanFeatureTool() },\\n] as const;\\n`;\n    fs.writeFileSync(toolIndexPath, toolContent, { encoding: \"utf8\" });\n\n    // Write module index.ts\n    const moduleIndex = path.join(moduleRoot, \"index.ts\");\n    const moduleIndexContent = `import { prompts } from './prompts';\\nimport { resources } from './resources';\\nimport { templates } from './templates';\\nimport { tools } from './tools';\\nexport { prompts } from './prompts';\\nexport { resources } from './resources';\\nexport { templates } from './templates';\\nexport { tools } from './tools';\\nexport const modulePackage = { name: '${inferredName}', prompts, resources, templates, tools } as const;\\n`;\n    fs.writeFileSync(moduleIndex, moduleIndexContent, { encoding: \"utf8\" });\n\n    return {\n      content: [\n        {\n          type: \"text\",\n          text: JSON.stringify(\n            {\n              moduleRoot,\n              inferredName,\n              analysisSummary: {\n                files: analysis.files.length,\n                testFiles: analysis.testFiles.length,\n              },\n            },\n            null,\n            2\n          ),\n        },\n      ],\n    };\n  },\n};\n\nexport default generateMcpModuleTool;\n","import { decoratorTools } from \"../decorator-tools\";\nimport { moduleRegistry } from \"../moduleRegistry\";\nimport {\n  applyCodeChangeTool,\n  documentCodeTool,\n  toolList as coreToolList,\n} from \"./tools\";\nimport {\n  coverageEnforcerTool,\n  documentObjectTool,\n  readmeImprovementTool,\n} from \"./codex-tools\";\n\nexport * from \"./tools\";\nexport * from \"./codex-tools\";\nexport * from \"./generateMcpModule\";\n\nconst codexToolList = [\n  documentObjectTool,\n  coverageEnforcerTool,\n  readmeImprovementTool,\n];\n\nconst moduleToolList = moduleRegistry.listTools().map((asset) => asset.tool as any);\n\nexport const toolList = [...coreToolList, ...codexToolList, ...moduleToolList];\nexport const decoratorToolList = Object.values(decoratorTools);\nconst [\n  analyzeRepositoryTool,\n  enumerateCapabilitiesTool,\n  planFeatureTool,\n  documentCodeToolRef,\n  applyCodeChangeToolRef,\n] = coreToolList;\n\nexport const tools = {\n  analyzeRepositoryTool,\n  enumerateCapabilitiesTool,\n  planFeatureTool,\n  documentCodeTool: documentCodeToolRef,\n  applyCodeChangeTool: applyCodeChangeToolRef,\n  documentObjectTool,\n  coverageEnforcerTool,\n  readmeImprovementTool,\n  ...decoratorTools,\n};\n\nexport { decoratorTools };","import type { Resource } from \"fastmcp\";\nimport type { ResourceAsset } from \"../../types\";\nimport { moduleRegistry } from \"../moduleRegistry\";\nimport { getWorkspaceRoot } from \"../workspace\";\nimport { buildObjectPrompts, discoverDocPrompts } from \"../prompts/prompts\";\n\nfunction toResource(asset: ResourceAsset): Resource<undefined> {\n  return {\n    name: asset.id,\n    uri: asset.uri,\n    description: asset.description ?? asset.title,\n    mimeType: asset.mimeType,\n    load: async () => {\n      const res = await asset.load();\n      // asset.load may return a ContentResult or a Promise of ContentResult; ensure we return ResourceResult-like object\n      if ((res as any)?.content) {\n        const cr = res as any;\n        // If ContentResult, convert to simple text result expected by Resource.load consumers\n        return {\n          text: Array.isArray(cr.content)\n            ? cr.content.map((c: any) => c.text).join(\"\\n\")\n            : String(cr),\n        };\n      }\n      // fallback for objects with text\n      return res as any as { text: string };\n    },\n  };\n}\n\nfunction buildModuleResources(): Resource<undefined>[] {\n  return moduleRegistry.listResources().map(toResource);\n}\n\nexport const resources: Resource<undefined>[] = [\n  {\n    name: \"codex-prompt-index\",\n    uri: \"codex://prompts/index\",\n    description:\n      \"Enumerate available .codex prompt files with titles and descriptions.\",\n    mimeType: \"application/json\",\n    load: async () => {\n      const root = getWorkspaceRoot();\n      const prompts = discoverDocPrompts(root).map((prompt) => ({\n        name: prompt.name,\n        title: prompt.title,\n        description: prompt.description,\n        path: prompt.absolutePath,\n      }));\n      return {\n        text: JSON.stringify({ prompts }, null, 2),\n        mimeType: \"application/json\",\n      };\n    },\n  },\n  {\n    name: \"codex-object-prompts\",\n    uri: \"codex://prompts/objects\",\n    description:\n      \"Provides the resolved prompt content for each documented object workflow.\",\n    mimeType: \"application/json\",\n    load: async () => {\n      const entries = await Promise.all(\n        buildObjectPrompts().map(async (prompt) => ({\n          name: prompt.name,\n          description: prompt.description,\n          content: await prompt.load({} as never),\n        }))\n      );\n      return {\n        text: JSON.stringify({ prompts: entries }, null, 2),\n        mimeType: \"application/json\",\n      };\n    },\n  },\n  ...buildModuleResources(),\n];\n","import path from \"path\";\nimport fs from \"fs\";\nimport { getWorkspaceRoot, resolveInWorkspace } from \"../workspace\";\nimport type { PromptResourceTemplate } from \"../types\";\n\nexport const codexPromptTemplates: PromptResourceTemplate[] = [];\n\nexport function buildCodexPromptTemplates(): PromptResourceTemplate[] {\n  const root = getWorkspaceRoot();\n  const templates: PromptResourceTemplate[] = [\n    {\n      name: \"codex-prompt\",\n      description:\n        \"Load a .codex prompt file by name (without extension) as markdown.\",\n      uriTemplate: \"codex-prompt://{name}\",\n      mimeType: \"text/markdown\",\n      arguments: [\n        {\n          name: \"name\",\n          description:\n            \"Name of the prompt file inside .codex/prompts (without .md).\",\n          required: true,\n        },\n      ],\n      load: async ({ name }) => {\n        const promptPath = resolveInWorkspace(\n          root,\n          path.join(\".codex\", \"prompts\", `${name}.md`)\n        );\n        if (!fs.existsSync(promptPath)) {\n          throw new Error(`Prompt .codex/prompts/${name}.md not found`);\n        }\n        const text = fs.readFileSync(promptPath, \"utf8\");\n        return { text, uri: `codex-prompt:///${name}` };\n      },\n    },\n  ];\n\n  codexPromptTemplates.splice(0, codexPromptTemplates.length, ...templates);\n  return codexPromptTemplates;\n}\n","import path from \"path\";\nimport type { DecorationResourceTemplate } from \"../types\";\nimport { getWorkspaceRoot, readWorkspaceFile } from \"../workspace\";\n\nexport const decorationResourceTemplates: DecorationResourceTemplate[] = [];\n\nfunction makeLoader(type: \"src\" | \"tests\" | \"workdocs\") {\n  return async ({ path: relative }: { path: string }) => {\n    const root = getWorkspaceRoot();\n    const target = path.join(type, relative);\n    const text = await readWorkspaceFile(root, target);\n    return { text };\n  };\n}\n\nexport function buildDecorationResourceTemplates(): DecorationResourceTemplate[] {\n  const templates: DecorationResourceTemplate[] = [\n    {\n      name: \"read-code-from-source\",\n      description:\n        \"Read a file from the <base_path>/src tree by relative path.\",\n      mimeType: \"text/plain\",\n      uriTemplate: \"from-source://src/{path}\",\n      arguments: [\n        {\n          name: \"path\",\n          description:\n            \"Path under <base_path>/src to load, e.g. 'decoration/types.ts'\",\n          required: true,\n        },\n      ],\n      load: makeLoader(\"src\"),\n    },\n    {\n      name: \"read-test-from-source\",\n      description:\n        \"Read a file from the <base_path>/tests tree by relative path.\",\n      mimeType: \"text/plain\",\n      uriTemplate: \"from-source://tests/{path}\",\n      arguments: [\n        {\n          name: \"path\",\n          description:\n            \"Path under <base_path>/tests to load, e.g. 'decoration/tests/types.test.ts'\",\n          required: true,\n        },\n      ],\n      load: makeLoader(\"tests\"),\n    },\n    {\n      name: \"read-doc-from-source\",\n      description:\n        \"Read a file from the <base_path>/workdocs tree by relative path.\",\n      mimeType: \"text/plain\",\n      uriTemplate: \"from-source://workdocs/{path}\",\n      arguments: [\n        {\n          name: \"path\",\n          description:\n            \"Path under <base_path>/workdocs to load, e.g. 'decoration/workdocs/tutorials/for-developers.md'\",\n          required: true,\n        },\n      ],\n      load: makeLoader(\"workdocs\"),\n    },\n  ];\n\n  decorationResourceTemplates.splice(\n    0,\n    decorationResourceTemplates.length,\n    ...templates\n  );\n  return decorationResourceTemplates;\n}\n","import { WorkspaceResourceTemplate } from \"../types\";\nimport { getWorkspaceRoot, readWorkspaceFile } from \"../workspace\";\n\nexport const workspaceResourceTemplates: WorkspaceResourceTemplate[] = [];\n\nexport function buildWorkspaceResourceTemplates(): 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  const templates: WorkspaceResourceTemplate[] = [\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        try {\n          const text = await readWorkspaceFile(root, args.path);\n          return { text: String(text) };\n        } catch (err) {\n          // propagate as-is for tests to assert errors\n          throw err;\n        }\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        try {\n          const text = await readWorkspaceFile(root, args.path);\n          return { text: String(text) };\n        } catch (err) {\n          throw err;\n        }\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        try {\n          const text = await readWorkspaceFile(root, args.path);\n          return { text: String(text) };\n        } catch (err) {\n          throw err;\n        }\n      },\n    },\n  ];\n\n  workspaceResourceTemplates.splice(\n    0,\n    workspaceResourceTemplates.length,\n    ...templates\n  );\n  return workspaceResourceTemplates;\n}\n\n","import {\n  buildCodexPromptTemplates,\n  codexPromptTemplates,\n} from \"./codex-templates\";\nimport {\n  buildDecorationResourceTemplates,\n  decorationResourceTemplates,\n} from \"./resource-templates\";\nimport {\n  buildWorkspaceResourceTemplates,\n  workspaceResourceTemplates,\n} from \"./workspace-templates\";\nimport type { TemplateAsset } from \"../../types\";\nimport { moduleRegistry } from \"../moduleRegistry\";\n\nexport {\n  buildCodexPromptTemplates,\n  codexPromptTemplates,\n} from \"./codex-templates\";\nexport {\n  buildDecorationResourceTemplates,\n  decorationResourceTemplates,\n} from \"./resource-templates\";\nexport {\n  buildWorkspaceResourceTemplates,\n  workspaceResourceTemplates,\n} from \"./workspace-templates\";\n\nexport function buildResourceTemplates() {\n  const moduleTemplates = moduleRegistry.listTemplates().map((template) => ({\n    name: template.id,\n    description: template.description ?? template.title,\n    mimeType: \"text/markdown\",\n    uriTemplate: `module-template://${template.id}`,\n    arguments: (template.placeholders ?? []).map((name) => ({\n      name,\n      description: `Value for ${name}`,\n      required: true,\n    })),\n    load: async () => ({\n      text:\n        typeof (template as any).content === \"string\"\n          ? (template as any).content\n          : `# ${template.description ?? template.title ?? template.id}\\n\\nNo template content available for ${template.id}`,\n    }),\n  }));\n\n  const all = [\n    ...buildWorkspaceResourceTemplates(),\n    ...buildCodexPromptTemplates(),\n    ...buildDecorationResourceTemplates(),\n    ...moduleTemplates,\n  ];\n\n  // Normalise all loaders to always return { text: string }\n  function normaliseResult(res: any) {\n    if (res == null) return { text: \"\" };\n    if (typeof res === \"string\") return { text: res };\n    if (typeof res.text === \"string\") return res;\n    // handle legacy ContentResult shapes with content or content array\n    if (Array.isArray(res.content)) {\n      const parts = res.content\n        .map((c: any) => (c && typeof c.text === \"string\" ? c.text : String(c)))\n        .join(\"\\n\");\n      return { text: parts };\n    }\n    if (res.content && typeof res.content.text === \"string\") {\n      return { text: res.content.text };\n    }\n    // fallback: stringify\n    try {\n      return { text: JSON.stringify(res) };\n    } catch {\n      return { text: String(res) };\n    }\n  }\n\n  return all.map((t) => ({\n    ...t,\n    load: async (args: any) => {\n      const raw = await (t.load as any)(args);\n      return normaliseResult(raw);\n    },\n  }));\n}\n\nexport const templateList = buildResourceTemplates();\n","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 type { FastMCP } from \"fastmcp\";\nimport { PACKAGE_NAME as PKG, VERSION as V } from \"../metadata\";\nimport {\n  buildDocPrompts,\n  buildPrompts,\n  buildDocumentationPayload,\n  discoverDocPrompts,\n  loadPrompts,\n  promptList,\n  refreshPrompts,\n  selectPrompt,\n  DEFAULT_PROMPT_NAME,\n} from \"./prompts\";\nimport { resources } from \"./resources\";\nimport {\n  buildDecorationResourceTemplates,\n  buildResourceTemplates,\n  decorationResourceTemplates,\n  templateList,\n  workspaceResourceTemplates,\n} from \"./templates\";\nimport { toolList, tools } from \"./tools\";\nimport {\n  __resetWorkspaceRoot,\n  getWorkspaceRoot,\n  setWorkspaceRoot,\n} from \"./workspace\";\n\nexport function enrich(mcp: FastMCP): FastMCP {\n  const promptEntries = loadPrompts();\n  for (const prompt of promptEntries) {\n    mcp.addPrompt(prompt as any);\n  }\n\n  for (const tool of toolList) {\n    mcp.addTool(tool as any);\n  }\n\n  const templates = buildResourceTemplates();\n  for (const template of templates) {\n    mcp.addResourceTemplate(template as any);\n  }\n\n  for (const resource of resources) {\n    const addResource = (mcp as unknown as { addResource?: (res: unknown) => void }).addResource;\n    if (typeof addResource === \"function\") {\n      addResource.call(mcp, resource as any);\n    }\n  }\n\n  return mcp;\n}\n\nexport default enrich;\nexport const PACKAGE_NAME = PKG;\nexport const VERSION = V;\n\nexport {\n  tools,\n  toolList,\n  buildDocPrompts,\n  buildPrompts,\n  buildDecorationResourceTemplates,\n  buildResourceTemplates,\n  buildDocumentationPayload,\n  decorationResourceTemplates,\n  discoverDocPrompts,\n  DEFAULT_PROMPT_NAME,\n  promptList,\n  refreshPrompts,\n  resources,\n  selectPrompt,\n  templateList,\n  workspaceResourceTemplates,\n  getWorkspaceRoot,\n  setWorkspaceRoot,\n  __resetWorkspaceRoot,\n};\n","// New: validation entrypoint for module structure\nimport fs from \"fs\";\nimport path from \"path\";\n\nexport type ValidationIssue = {\n  module: string;\n  path: string;\n  type:\n    | \"missing-folder\"\n    | \"missing-export\"\n    | \"empty-list\"\n    | \"disabled\"\n    | \"other\";\n  detail?: string;\n};\n\nexport type ValidationReport = {\n  ok: boolean;\n  modulesChecked: number;\n  issues: ValidationIssue[];\n};\n\nconst REQUIRED_SUBFOLDERS = [\"prompts\", \"resources\", \"templates\", \"tools\"];\n\nexport function findModuleDirs(repoRoot: string): string[] {\n  const modulesPath = path.resolve(repoRoot, \"src\", \"modules\");\n  if (!fs.existsSync(modulesPath) || !fs.statSync(modulesPath).isDirectory()) {\n    return [];\n  }\n  return fs\n    .readdirSync(modulesPath, { withFileTypes: true })\n    .filter((d) => d.isDirectory())\n    .map((d) => path.join(modulesPath, d.name));\n}\n\nfunction hasIndexExport(folderPath: string): boolean {\n  const candidates = [\n    \"index.ts\",\n    \"index.tsx\",\n    \"index.js\",\n    \"index.cjs\",\n    \"index.mjs\",\n  ];\n  for (const c of candidates) {\n    if (fs.existsSync(path.join(folderPath, c))) return true;\n  }\n  return false;\n}\n\nexport function validateModules(repoRoot: string): ValidationReport {\n  const dirs = findModuleDirs(repoRoot);\n  const issues: ValidationIssue[] = [];\n\n  for (const moduleDir of dirs) {\n    const moduleName = path.basename(moduleDir);\n    for (const sub of REQUIRED_SUBFOLDERS) {\n      const subPath = path.join(moduleDir, sub);\n      if (!fs.existsSync(subPath) || !fs.statSync(subPath).isDirectory()) {\n        issues.push({\n          module: moduleName,\n          path: subPath,\n          type: \"missing-folder\",\n          detail: `Required folder '${sub}' is missing in module '${moduleName}'`,\n        });\n        continue;\n      }\n      // If folder exists, check for index export\n      if (!hasIndexExport(subPath)) {\n        issues.push({\n          module: moduleName,\n          path: subPath,\n          type: \"missing-export\",\n          detail: `No index export found in '${subPath}'. Expected one of index.ts, index.js, etc.`,\n        });\n        continue;\n      }\n      // Optionally inspect the index file to see if it exports a list (lightweight check)\n      try {\n        const indexFile = candidatesFindingIndex(subPath);\n        if (indexFile) {\n          const content = fs.readFileSync(indexFile, \"utf8\");\n          // crude heuristics: look for `export const name = [` or `export const name: Type[] = [`,\n          // or any named export like `export { something }` which implies exports exist.\n          const exportListPattern =\n            /export\\s+(const|let|var)\\s+[\\w$]+(?:\\s*:\\s*[^=]+)?\\s*=\\s*\\[/;\n          if (\n            !exportListPattern.test(content) &&\n            !/export\\s+\\{/.test(content)\n          ) {\n            issues.push({\n              module: moduleName,\n              path: indexFile,\n              type: \"empty-list\",\n              detail: `Index file does not appear to export a list of assets: ${path.basename(indexFile)}`,\n            });\n          }\n        }\n      } catch (err: any) {\n        issues.push({\n          module: moduleName,\n          path: subPath,\n          type: \"other\",\n          detail: `Error reading index file: ${err.message}`,\n        });\n      }\n    }\n  }\n\n  return {\n    ok: issues.length === 0,\n    modulesChecked: dirs.length,\n    issues,\n  };\n}\n\nfunction candidatesFindingIndex(folderPath: string): string | undefined {\n  const candidates = [\n    \"index.ts\",\n    \"index.tsx\",\n    \"index.js\",\n    \"index.cjs\",\n    \"index.mjs\",\n  ];\n  for (const c of candidates) {\n    const full = path.join(folderPath, c);\n    if (fs.existsSync(full)) return full;\n  }\n  return undefined;\n}\n\n// CLI helper\nif (require.main === module) {\n  const repoRoot = process.cwd();\n  const report = validateModules(repoRoot);\n  if (!report.ok) {\n    console.error(\n      \"Module validation failed:\\n\",\n      JSON.stringify(report, null, 2)\n    );\n    process.exit(2);\n  }\n  console.log(\"Module validation passed\");\n  process.exit(0);\n}\n","// Aggregator: import module index files and merge exported arrays with provenance + duplicate detection\nimport path from \"path\";\nimport fs from \"fs\";\nimport { pathToFileURL } from \"url\";\nimport { findModuleDirs } from \"./validation\";\n\nexport type Provenance = { moduleName: string; modulePath: string };\nexport type AggregationConflict = {\n  key: string;\n  existing: Provenance;\n  incoming: Provenance;\n};\n\nexport type AggregationResult<T = any> = {\n  prompts: Array<T & { provenance: Provenance }>;\n  resources: Array<T & { provenance: Provenance }>;\n  templates: Array<T & { provenance: Provenance }>;\n  tools: Array<T & { provenance: Provenance }>;\n  conflicts: AggregationConflict[];\n};\n\nconst SUBFOLDERS = [\"prompts\", \"resources\", \"templates\", \"tools\"];\nconst INDEX_CANDIDATES = [\n  \"index.ts\",\n  \"index.tsx\",\n  \"index.js\",\n  \"index.cjs\",\n  \"index.mjs\",\n];\n\nfunction findIndexFile(folder: string): string | undefined {\n  for (const c of INDEX_CANDIDATES) {\n    const f = path.join(folder, c);\n    if (fs.existsSync(f)) return f;\n  }\n  return undefined;\n}\n\nfunction makeKeyForItem(item: any): string {\n  if (!item) return JSON.stringify(item);\n  if (typeof item === \"string\") return `str:${item}`;\n  if (typeof item === \"number\") return `num:${item}`;\n  if (item.id) return `id:${item.id}`;\n  if (item.name) return `name:${item.name}`;\n  // fallback to stable string\n  try {\n    return `obj:${JSON.stringify(item)}`;\n  } catch (e) {\n    return `obj:${String(item)}`;\n  }\n}\n\nasync function loadArrayFromIndex(\n  filePath: string\n): Promise<any[] | undefined> {\n  // Prefer a fast, static parse of the first array literal found in the file.\n  try {\n    const content = fs.readFileSync(filePath, \"utf8\");\n    const start = content.indexOf(\"[\");\n    if (start !== -1) {\n      let depth = 0;\n      let end = -1;\n      for (let i = start; i < content.length; i++) {\n        const ch = content[i];\n        if (ch === \"[\") depth++;\n        else if (ch === \"]\") {\n          depth--;\n          if (depth === 0) {\n            end = i;\n            break;\n          }\n        }\n      }\n      if (end !== -1) {\n        const arrText = content.slice(start, end + 1);\n        try {\n          return JSON.parse(arrText);\n        } catch (e) {\n          // Normalize TS object literals to JSON:\n          // - convert single quotes to double quotes\n          // - quote unquoted object keys\n          // - strip trailing commas\n          const normalized = arrText\n            // unify quotes in string literals\n            .replace(/'(?:\\\\'|[^'])*'/g, (m) => m.replace(/'/g, '\"'))\n            // quote unquoted keys after { or ,\n            .replace(/([\\{,]\\s*)([A-Za-z_$][\\w$]*)(\\s*:)/g, '$1\"$2\"$3')\n            // remove trailing commas before ] or }\n            .replace(/,(\\s*[\\}\\]])/g, '$1');\n          try {\n            return JSON.parse(normalized);\n          } catch (e2) {\n            // fallthrough to import attempt below\n          }\n        }\n      }\n    }\n  } catch (e) {\n    // ignore static parse errors and fall back to import\n  }\n\n  try {\n    const fileUrl = pathToFileURL(filePath).href;\n    const mod = await import(fileUrl);\n    // Find first export that is an array\n    for (const key of Object.keys(mod)) {\n      const val = (mod as any)[key];\n      if (Array.isArray(val)) return val;\n    }\n    // default export check\n    if (Array.isArray((mod as any).default)) return (mod as any).default;\n    return undefined;\n  } catch (err) {\n    // fallback: if import fails, try to static-parse again (already attempted) and finally return undefined\n    return undefined;\n  }\n}\n\nexport async function aggregateModules(\n  repoRoot: string\n): Promise<AggregationResult> {\n  const dirs = findModuleDirs(repoRoot);\n  const master = {\n    prompts: [] as any[],\n    resources: [] as any[],\n    templates: [] as any[],\n    tools: [] as any[],\n    conflicts: [] as AggregationConflict[],\n  };\n\n  // maps to detect duplicates per type\n  const maps: Record<string, Map<string, Provenance>> = {\n    prompts: new Map(),\n    resources: new Map(),\n    templates: new Map(),\n    tools: new Map(),\n  };\n\n  for (const moduleDir of dirs) {\n    const moduleName = path.basename(moduleDir);\n    for (const sub of SUBFOLDERS) {\n      const folder = path.join(moduleDir, sub);\n      const indexFile = findIndexFile(folder);\n      if (!indexFile) continue;\n      let arr: any[] | undefined;\n      try {\n        arr = await loadArrayFromIndex(indexFile);\n      } catch (err: any) {\n        // skip module on import error but record as conflict-like issue\n        master.conflicts.push({\n          key: `import-error:${moduleName}:${sub}`,\n          existing: { moduleName, modulePath: moduleDir },\n          incoming: { moduleName, modulePath: moduleDir },\n        });\n        continue;\n      }\n      if (!arr || !Array.isArray(arr)) continue;\n\n      for (const item of arr) {\n        const key = makeKeyForItem(item);\n        const provenance = { moduleName, modulePath: moduleDir };\n        const map = maps[sub];\n        if (map.has(key)) {\n          // record conflict deterministically (existing vs incoming)\n          const existing = map.get(key)!;\n          master.conflicts.push({ key, existing, incoming: provenance });\n          // skip adding duplicate\n          continue;\n        }\n        map.set(key, provenance);\n        (master as any)[sub].push({ ...item, provenance });\n      }\n    }\n  }\n\n  return master;\n}\n\n// For compatibility with CommonJS call sites (not exported by ESM), provide a sync wrapper\nexport function aggregateModulesSync(repoRoot: string) {\n  // synchronous wrapper that runs the async function and blocks — suitable for small module sets\n  const p = aggregateModules(repoRoot);\n  let result: any;\n  let done = false;\n  p.then((r) => {\n    result = r;\n    done = true;\n  }).catch((e) => {\n    throw e;\n  });\n  // spin-wait (acceptable in small dev scripts)\n  const until = Date.now() + 5000;\n  while (!done && Date.now() < until) {}\n  if (!done)\n    throw new Error(\n      \"aggregateModulesSync: timeout waiting for async aggregation\"\n    );\n  return result as AggregationResult;\n}\n","import { aggregateModules } from \"./aggregateModules\";\nimport { loadPrompts, promptList } from \"./prompts\";\nimport { toolList } from \"./tools\";\nimport { resources } from \"./resources\";\nimport { buildResourceTemplates } from \"./templates\";\n\nexport type FastMCPLike = {\n  addPrompt: (p: any) => void;\n  addTool: (t: any) => void;\n  addResource: (r: any) => void;\n  addResourceTemplate: (t: any) => void;\n};\n\n/**\n * Aggregate module assets and register them on the provided FastMCP-like server.\n * Falls back to built-in lists if aggregation yields none.\n */\nexport async function EnrichCoreWithAggregation(\n  server: FastMCPLike,\n  repoRoot = process.cwd()\n) {\n  // First register built-in prompts/tools/resources/templates (legacy behavior)\n  try {\n    loadPrompts();\n    for (const prompt of promptList) server.addPrompt(prompt as any);\n  } catch (e) {\n    // ignore if loadPrompts not available or fails\n  }\n\n  try {\n    for (const tool of toolList) server.addTool(tool as any);\n  } catch (e) {}\n\n  try {\n    for (const resource of resources) server.addResource(resource as any);\n  } catch (e) {}\n\n  try {\n    const templates = buildResourceTemplates();\n    for (const template of templates)\n      server.addResourceTemplate(template as any);\n  } catch (e) {}\n\n  // Now aggregate modules and register aggregated assets with provenance\n  const agg = await aggregateModules(repoRoot);\n\n  for (const p of agg.prompts) {\n    server.addPrompt(p);\n  }\n  for (const t of agg.tools) {\n    server.addTool(t);\n  }\n  for (const r of agg.resources) {\n    server.addResource(r);\n  }\n  for (const tpl of agg.templates) {\n    server.addResourceTemplate(tpl);\n  }\n\n  // return aggregation summary for calling tests/CI\n  return {\n    modulesChecked: agg.prompts.concat(agg.tools).length,\n    conflicts: agg.conflicts,\n  };\n}\n","import { FastMCP } from \"fastmcp\";\nimport { loadPrompts, promptList } from \"./prompts\";\nimport { toolList } from \"./tools\";\nimport { resources } from \"./resources\";\nimport { buildResourceTemplates } from \"./templates\";\n\nexport * from \"./mcp-module\";\nexport { default } from \"./mcp-module\";\n\nexport { validateModules } from \"./validation\";\nexport { aggregateModules, aggregateModulesSync } from \"./aggregateModules\";\nexport { EnrichCoreWithAggregation } from \"./fastmcp-wiring\";\n\nexport function EnrichCore(server: FastMCP) {\n  loadPrompts();\n  for (const prompt of promptList) {\n    server.addPrompt(prompt as any);\n  }\n  for (const tool of toolList) {\n    server.addTool(tool as any);\n  }\n  for (const resource of resources) {\n    server.addResource(resource as any);\n  }\n  const templates = buildResourceTemplates();\n  for (const template of templates) {\n    server.addResourceTemplate(template as any);\n  }\n}\n","import fs from \"node:fs\";\nimport path from \"node:path\";\nimport { getWorkspaceRoot } from \"../mcp/workspace\";\n\nexport const REQUIRED_MODULE_FOLDERS = [\n  \"prompts\",\n  \"resources\",\n  \"templates\",\n  \"tools\",\n] as const;\n\nexport type ModuleFolder = (typeof REQUIRED_MODULE_FOLDERS)[number];\n\nexport function resolveModulesRoot(workspaceRoot = getWorkspaceRoot()): string {\n  return path.resolve(workspaceRoot, \"src/modules\");\n}\n\nexport function listModuleDirectories(workspaceRoot = getWorkspaceRoot()): string[] {\n  const root = resolveModulesRoot(workspaceRoot);\n  if (!fs.existsSync(root)) return [];\n\n  return fs\n    .readdirSync(root)\n    .map((entry) => ({\n      entry,\n      absolute: path.join(root, entry),\n    }))\n    .filter(({ absolute }) => fs.statSync(absolute).isDirectory())\n    .map(({ entry }) => entry)\n    .sort();\n}\n\nexport function resolveModulePath(\n  moduleName: string,\n  workspaceRoot = getWorkspaceRoot()\n): string {\n  return path.join(resolveModulesRoot(workspaceRoot), moduleName);\n}\n\nexport function resolveModuleFolderPath(\n  moduleName: string,\n  folder: ModuleFolder,\n  workspaceRoot = getWorkspaceRoot()\n): string {\n  return path.join(resolveModulePath(moduleName, workspaceRoot), folder);\n}\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\nexport * from \"./utils/modulePaths\";\n","import 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 {FastMCP} 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    let server = this.mcp;\n    // discover modules by crawling basePath\n    const moduleFiles = this.crawl(\n      path.resolve(this.basePath),\n      this.crawlLevels\n    );\n    for (const moduleFile of moduleFiles) {\n      if (moduleFile.includes(\"@decaf-ts/mcp\")) {\n        continue;\n      }\n      try {\n        const res = await this.load(server, moduleFile);\n        server = res.mcp;\n        this.modules[res.package] = moduleFile;\n      } catch (e: unknown) {\n        log.error(\n          `Failed to load MCP configs for ${moduleFile}: ${e instanceof Error ? e.message : e}`\n        );\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":["prompts","resources","templates","z","applyPatch","createTwoFilesPatch","toolList","tools","modulePackage","decorationModule","mcpModule","templateModule","spawnSync","coreToolList","VERSION","PACKAGE_NAME","Metadata","PKG","V","pathToFileURL","path","fs","LoggedClass","FastMCP"],"mappings":"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"}