@decaf-ts/mcp-server 0.0.4 → 0.2.0

package/dist/mcp-server.esm.cjs

@@ -2,29 +2,997 @@ import fs from 'fs';
 import path from 'path';
 import { applyPatch, createTwoFilesPatch } from 'diff';
 import { z } from 'zod';
+import { spawnSync } from 'child_process';
 import { Metadata } from '@decaf-ts/decoration';
+import { pathToFileURL } from 'url';
+import fs$1 from 'node:fs';
+import path$1 from 'node:path';
 import { FastMCP } from 'fastmcp';
 import { LoggedClass } from '@decaf-ts/logging';
 
 /**
- * @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.3";
-const PACKAGE_NAME$1 = "##PACKAGE_NAME##";
-try {
-    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 = z
+    .object({
+    repoPath: z
+        .string()
+        .min(1, "repoPath is required")
+        .describe("Relative or absolute path to the target repository inside this monorepo, e.g. './decoration'."),
+    includeTests: z
+        .boolean()
+        .default(true)
+        .describe("If true, analyze the tests directory (if present) to derive expected behaviors."),
+    includeDocs: 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 = z
+    .object({
+    repoPath: 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 = z
+    .object({
+    feature: 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: 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 = z
+    .object({
+    filePath: z.string().min(1, "filePath is required"),
+    promptName: z.string().optional(),
+    includePrompt: z.boolean().default(true),
+    includeCode: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    additionalContext: z.string().optional(),
+    encoding: z.string().default("utf8"),
+})
+    .strict();
+const codeChangeSchema = z
+    .object({
+    filePath: z.string().min(1, "filePath is required"),
+    patch: z.string().min(1, "patch is required"),
+    dryRun: z.boolean().default(false),
+    showDiff: z.boolean().default(true),
+    diffContext: z.number().int().min(0).max(100).default(3),
+    encoding: z.string().default("utf8"),
+})
+    .strict();
+const OBJECT_TYPES = [
+    "module",
+    "file",
+    "class",
+    "function",
+    "interface",
+    "decorator",
+    "constant",
+];
+const documentObjectSchema = z
+    .object({
+    basePath: z.string().min(1, "basePath is required"),
+    objectType: z.enum(OBJECT_TYPES),
+    targetFile: z.string().optional(),
+    includeContent: z.boolean().default(false),
+})
+    .strict();
+const coverageTaskSchema = z
+    .object({
+    basePath: z.string().min(1, "basePath is required"),
+    coverage: z
+        .number()
+        .min(0)
+        .max(100)
+        .default(90)
+        .describe("Target coverage percentage"),
+    dryRun: z.boolean().default(false),
+})
+    .strict();
+const readmeImprovementSchema = z
+    .object({
+    basePath: z.string().min(1, "basePath is required"),
+    includeExamples: 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 = 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 = 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, "\\$&");
 }
@@ -249,224 +1217,522 @@ const decoratorTools = {
             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 = z
-    .object({
-    filePath: z.string().min(1, "filePath is required"),
-    promptName: z.string().optional(),
-    includePrompt: z.boolean().default(true),
-    includeCode: z.boolean().default(true),
-    includeMetadata: z.boolean().default(true),
-    additionalContext: z.string().optional(),
-    encoding: z.string().default("utf8"),
-})
-    .strict();
-const codeChangeSchema = z
-    .object({
-    filePath: z.string().min(1, "filePath is required"),
-    patch: z.string().min(1, "patch is required"),
-    dryRun: z.boolean().default(false),
-    showDiff: z.boolean().default(true),
-    diffContext: z.number().int().min(0).max(100).default(3),
-    encoding: 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 = 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 = 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 = 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
+z.object({
+    repoPath: z.string().optional().default("."),
+    moduleName: z.string().optional(),
+    includeDocs: 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 = [
         {
@@ -475,7 +1741,7 @@ function buildResourceTemplates() {
             required: true,
         },
     ];
-    return [
+    const templates = [
         {
             name: "vscode-workspace-file",
             description: "Expose workspace files to Visual Studio Code via vscode:// URIs",
@@ -483,8 +1749,14 @@ function buildResourceTemplates() {
             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;
+                }
             },
         },
         {
@@ -494,8 +1766,13 @@ function buildResourceTemplates() {
             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;
+                }
             },
         },
         {
@@ -505,164 +1782,510 @@ function buildResourceTemplates() {
             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 {
+    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 = 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 */
 /**
@@ -747,7 +2370,6 @@ class McpUtils {
     }
 }
 
-/* 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.
@@ -776,7 +2398,7 @@ class McpWrapper extends LoggedClass {
     /**
      * @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() {
@@ -851,19 +2473,20 @@ class McpWrapper extends LoggedClass {
      */
     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)
@@ -922,5 +2545,5 @@ class McpWrapper extends LoggedClass {
     }
 }
 
-export { MCP_FILE_NAME, McpUtils, McpWrapper, PACKAGE_NAME, VERSION, buildDocPrompts, buildResourceTemplates, enrich, getWorkspaceRoot, setWorkspaceRoot, tools };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mcp-server.esm.cjs","sources":["../src/metadata.ts","../src/modules/mcp/decorator-tools.ts","../src/modules/mcp/mcp-module.ts","../src/constants.ts","../src/utils.ts","../src/McpWrapper.ts"],"sourcesContent":["import { Metadata } from \"@decaf-ts/decoration\";\n\n/**\n * @const VERSION\n * @name VERSION\n * @description Represents the current version of the ts-workspace module.\n * @summary The actual version number is replaced during the build process.\n * @type {string}\n */\nexport const VERSION = \"##VERSION##\";\nexport const PACKAGE_NAME = \"##PACKAGE_NAME##\";\n\ntry {\n  Metadata.registerLibrary(PACKAGE_NAME, VERSION);\n} catch (error) {\n  if (error instanceof Error && error.message.includes(\"already\")) {\n    // Ignore duplicate registration during tests/bundling checks.\n  } else {\n    throw error;\n  }\n}\n","import fs from \"fs\";\nimport path from \"path\";\n\nexport type DecoratorSpec = {\n  name: string;\n  args?: unknown[];\n};\n\nexport type AttributeSpec = {\n  name: string;\n  type: string;\n  decorators?: DecoratorSpec[];\n};\n\nfunction escapeRegExp(value: string) {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\nfunction formatDecorator(spec: DecoratorSpec): string {\n  const args = (spec.args || []).map((arg) => JSON.stringify(arg)).join(\", \");\n  return `@${spec.name}(${args})`;\n}\n\nfunction ensureDirectory(filePath: string) {\n  fs.mkdirSync(path.dirname(filePath), { recursive: true });\n}\n\nfunction collectDecoratorNames(\n  classDecorators: DecoratorSpec[] | undefined,\n  properties: AttributeSpec[] | undefined\n) {\n  const names = new Set<string>();\n  names.add(\"model\");\n  for (const decorator of classDecorators || []) {\n    names.add(decorator.name);\n  }\n  for (const property of properties || []) {\n    for (const decorator of property.decorators || []) {\n      names.add(decorator.name);\n    }\n  }\n  return names;\n}\n\nfunction ensureImport(\n  content: string,\n  importsFrom: string,\n  decorators: Set<string>\n) {\n  /* istanbul ignore next */\n  if (!decorators.size) return content;\n  const importRegex = new RegExp(\n    `import\\\\s+\\\\{([^}]+)\\\\}\\\\s+from\\\\s+[\"']${escapeRegExp(importsFrom)}[\"'];`\n  );\n  const match = content.match(importRegex);\n  const sorted = Array.from(decorators).sort();\n\n  if (match) {\n    const existing = match[1]\n      .split(\",\")\n      .map((name) => name.trim())\n      .filter(Boolean);\n    const merged = Array.from(new Set([...existing, ...sorted])).sort();\n    return content.replace(\n      importRegex,\n      `import { ${merged.join(\", \")} } from \"${importsFrom}\";`\n    );\n  }\n\n  const importLine = `import { ${sorted.join(\", \")} } from \"${importsFrom}\";`;\n  return `${importLine}\\n\\n${content}`;\n}\n\nfunction addPropertyBlock(property: AttributeSpec) {\n  const decorators = (property.decorators || [])\n    .map(formatDecorator)\n    .join(\"\\n  \");\n  const decoratorBlock = decorators ? `  ${decorators}\\n` : \"\";\n  return `${decoratorBlock}  ${property.name}: ${property.type};`;\n}\n\nfunction removePropertyBlock(content: string, propertyName: string) {\n  const lines = content.split(/\\r?\\n/);\n  const result: string[] = [];\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i];\n    if (\n      line.trim().startsWith(`@`) &&\n      lines[i + 1]?.includes(`${propertyName}:`)\n    ) {\n      continue;\n    }\n    if (line.includes(`${propertyName}:`)) {\n      // skip this line and any trailing blank line\n      continue;\n    }\n    result.push(line);\n  }\n  return result.join(\"\\n\");\n}\n\nfunction insertDecorator(\n  content: string,\n  decorator: DecoratorSpec,\n  target: {\n    kind: \"class\" | \"property\";\n    name?: string;\n  }\n) {\n  const decoratorLine = formatDecorator(decorator);\n  if (target.kind === \"class\") {\n    const classRegex = /(export\\s+class\\s+[^\\s{]+\\s*\\{)/;\n    if (content.includes(decoratorLine)) return content;\n    return content.replace(classRegex, `${decoratorLine}\\n$1`);\n  }\n  if (!target.name) return content;\n  const propertyRegex = new RegExp(\n    `(^\\\\s*)(?:@.*\\\\n\\\\1)*${escapeRegExp(target.name)}:`,\n    \"m\"\n  );\n  const match = propertyRegex.exec(content);\n  if (!match) return content;\n  const indent = match[1] || \"  \";\n  if (content.includes(`${indent}${decoratorLine}`)) return content;\n  return (\n    content.slice(0, match.index) +\n    `${indent}${decoratorLine}\\n` +\n    content.slice(match.index)\n  );\n}\n\nfunction removeDecorator(\n  content: string,\n  decoratorName: string,\n  target: {\n    kind: \"class\" | \"property\";\n    name?: string;\n  }\n) {\n  const decoratorRegex = new RegExp(\n    `^\\\\s*@${escapeRegExp(decoratorName)}\\\\([^)]*\\\\)`,\n    \"m\"\n  );\n  if (target.kind === \"class\") {\n    return content.replace(decoratorRegex, \"\");\n  }\n  if (target.name) {\n    const pattern = new RegExp(\n      `(^\\\\s*@${escapeRegExp(decoratorName)}\\\\([^)]*\\\\)\\\\s*$\\\\n)(?=\\\\s*${escapeRegExp(target.name)}:)`,\n      \"m\"\n    );\n    return content.replace(pattern, \"\");\n  }\n  return content;\n}\n\nfunction writeIfChanged(filePath: string, content: string) {\n  ensureDirectory(filePath);\n  fs.writeFileSync(filePath, content);\n}\n\nexport const decoratorTools = {\n  createOrUpdateModelTool: {\n    name: \"create-or-update-model\",\n    description: \"Create or update a validation-ready model class\",\n    execute: async (args: {\n      filePath: string;\n      className: string;\n      classDecorators?: DecoratorSpec[];\n      properties: AttributeSpec[];\n      importsFrom: string;\n      overwrite?: boolean;\n    }) => {\n      if (!args.overwrite && fs.existsSync(args.filePath)) {\n        throw new Error(`File already exists at ${args.filePath}`);\n      }\n      const decorators = collectDecoratorNames(\n        args.classDecorators,\n        args.properties\n      );\n      let content = `@model()`;\n      for (const decorator of args.classDecorators || []) {\n        content += `\\n${formatDecorator(decorator)}`;\n      }\n      const properties = (args.properties || [])\n        .map(addPropertyBlock)\n        .join(\"\\n\\n\");\n      content += `\\nexport class ${args.className} {\\n${properties ? `${properties}\\n` : \"\"}}\\n`;\n      content = ensureImport(content, args.importsFrom, decorators);\n      writeIfChanged(args.filePath, content);\n      return { filePath: args.filePath };\n    },\n  },\n  addAttributeTool: {\n    name: \"add-attribute\",\n    description: \"Add a decorated attribute to an existing model\",\n    execute: async (args: {\n      filePath: string;\n      className: string;\n      attribute: AttributeSpec;\n      importsFrom: string;\n    }) => {\n      if (!fs.existsSync(args.filePath)) {\n        throw new Error(`Model file not found at ${args.filePath}`);\n      }\n      let content = fs.readFileSync(args.filePath, \"utf8\");\n      if (content.includes(`${args.attribute.name}:`)) {\n        return { filePath: args.filePath };\n      }\n      const decorators = collectDecoratorNames(undefined, [args.attribute]);\n      content = ensureImport(content, args.importsFrom, decorators);\n      const insertionPoint = content.lastIndexOf(\"}\");\n      const block = addPropertyBlock(args.attribute);\n      const before = content.slice(0, insertionPoint).replace(/\\s*$/, \"\");\n      const after = content.slice(insertionPoint);\n      const updated = `${before}\\n${block}\\n${after}`;\n      writeIfChanged(args.filePath, updated);\n      return { filePath: args.filePath };\n    },\n  },\n  removeAttributeTool: {\n    name: \"remove-attribute\",\n    description: \"Remove an attribute from a model class\",\n    execute: async (args: {\n      filePath: string;\n      className: string;\n      attributeName: string;\n    }) => {\n      if (!fs.existsSync(args.filePath)) return { filePath: args.filePath };\n      const content = fs.readFileSync(args.filePath, \"utf8\");\n      const updated = removePropertyBlock(content, args.attributeName);\n      writeIfChanged(args.filePath, updated);\n      return { filePath: args.filePath };\n    },\n  },\n  applyDecoratorTool: {\n    name: \"apply-decorator\",\n    description: \"Apply a decorator to a class or property\",\n    execute: async (args: {\n      filePath: string;\n      className: string;\n      target: { kind: \"class\" | \"property\"; name?: string };\n      decorator: DecoratorSpec;\n      importsFrom: string;\n    }) => {\n      if (!fs.existsSync(args.filePath)) {\n        throw new Error(`Model file not found at ${args.filePath}`);\n      }\n      let content = fs.readFileSync(args.filePath, \"utf8\");\n      const decorators = new Set<string>([args.decorator.name]);\n      content = ensureImport(content, args.importsFrom, decorators);\n      content = insertDecorator(content, args.decorator, args.target);\n      writeIfChanged(args.filePath, content);\n      return { filePath: args.filePath };\n    },\n  },\n  removeDecoratorTool: {\n    name: \"remove-decorator\",\n    description: \"Remove a decorator from a class or property\",\n    execute: async (args: {\n      filePath: string;\n      className: string;\n      target: { kind: \"class\" | \"property\"; name?: string };\n      decoratorName: string;\n    }) => {\n      if (!fs.existsSync(args.filePath)) return { filePath: args.filePath };\n      let content = fs.readFileSync(args.filePath, \"utf8\");\n      content = removeDecorator(content, args.decoratorName, args.target);\n      writeIfChanged(args.filePath, content);\n      return { filePath: args.filePath };\n    },\n  },\n  scaffoldValidatorTool: {\n    name: \"scaffold-validator\",\n    description: \"Scaffold a validator class and optional decorator\",\n    execute: async (args: {\n      validatorsDir: string;\n      decoratorDir?: string;\n      name: string;\n    }) => {\n      const classFile = path.join(args.validatorsDir, `${args.name}.ts`);\n      ensureDirectory(classFile);\n      const classContent = `export class ${args.name} {\\n  validate(value: unknown): boolean {\\n    return value !== undefined;\\n  }\\n}\\n`;\n      fs.writeFileSync(classFile, classContent);\n      let decoratorFile: string | undefined;\n      if (args.decoratorDir) {\n        decoratorFile = path.join(\n          args.decoratorDir,\n          `${args.name}Decorator.ts`\n        );\n        ensureDirectory(decoratorFile);\n        fs.writeFileSync(\n          decoratorFile,\n          `export function ${args.name}Decorator() {\\n  return () => void 0;\\n}\\n`\n        );\n      }\n      return { classFile, decoratorFile };\n    },\n  },\n  scaffoldSerializerTool: {\n    name: \"scaffold-serializer\",\n    description: \"Scaffold a serializer class and optional registry\",\n    execute: async (args: {\n      dir: string;\n      name: string;\n      registerDir?: string;\n      setDefault?: boolean;\n    }) => {\n      const classFile = path.join(args.dir, `${args.name}.ts`);\n      ensureDirectory(classFile);\n      fs.writeFileSync(\n        classFile,\n        `export class ${args.name} {\\n  serialize(value: unknown): string {\\n    return JSON.stringify(value);\\n  }\\n}\\n`\n      );\n      let registerFile: string | undefined;\n      if (args.registerDir) {\n        registerFile = path.join(args.registerDir, `${args.name}Register.ts`);\n        ensureDirectory(registerFile);\n        fs.writeFileSync(\n          registerFile,\n          `export function register${args.name}() {\\n  return ${args.setDefault ? \"'default'\" : \"'optional'\"};\\n}\\n`\n        );\n      }\n      return { classFile, registerFile };\n    },\n  },\n  scaffoldHashingTool: {\n    name: \"scaffold-hashing\",\n    description: \"Scaffold a hashing function and optional registry\",\n    execute: async (args: {\n      dir: string;\n      name: string;\n      registerDir?: string;\n      setDefault?: boolean;\n    }) => {\n      const functionFile = path.join(args.dir, `${args.name}.ts`);\n      ensureDirectory(functionFile);\n      fs.writeFileSync(\n        functionFile,\n        `export function ${args.name}(value: string): string {\\n  return value.split('').reverse().join('');\\n}\\n`\n      );\n      let registerFile: string | undefined;\n      if (args.registerDir) {\n        registerFile = path.join(args.registerDir, `${args.name}Register.ts`);\n        ensureDirectory(registerFile);\n        fs.writeFileSync(\n          registerFile,\n          `export function register${args.name}() {\\n  return ${args.setDefault ? \"'default'\" : \"'optional'\"};\\n}\\n`\n        );\n      }\n      return { functionFile, registerFile };\n    },\n  },\n} as const;\n\nexport type DecoratorTools = typeof decoratorTools;\n","import fs from \"fs\";\nimport path from \"path\";\nimport type { FastMCP, ContentResult, InputPrompt, Tool } from \"fastmcp\";\nimport { applyPatch, createTwoFilesPatch } from \"diff\";\nimport { z } from \"zod\";\nimport { PACKAGE_NAME as PKG, VERSION as V } from \"../../metadata\";\nimport { decoratorTools } from \"./decorator-tools\";\n\nconst WORKSPACE_ROOT_ENV = \"MCP_WORKSPACE_ROOT\";\nconst PROMPT_DIRECTORIES = [\".code/prompts\", \".codex/prompts\"];\nconst DEFAULT_PROMPT_NAME = \"doc\";\nconst CLIENT_INTEGRATIONS = [\n  {\n    id: \"vscode\",\n    display: \"Visual Studio Code\",\n    instructions:\n      \"When interacting from Visual Studio Code, prefer the vscode://workspace/{path} resource template to fetch file contents and use the apply-code-change tool to commit edits with previewable diffs.\",\n  },\n  {\n    id: \"cursor\",\n    display: \"Cursor\",\n    instructions:\n      \"Cursor clients can retrieve and update files through the cursor://workspace/{path} resource template. Always validate patches in dryRun mode before applying permanent changes.\",\n  },\n  {\n    id: \"copilot\",\n    display: \"GitHub Copilot\",\n    instructions:\n      \"Use the copilot://workspace/{path} resource template to stream file content into Copilot chat sessions. Prefer returning unified diffs to maintain alignment with Copilot's diff visualization.\",\n  },\n] as const;\n\nconst documentCodeSchema = z\n  .object({\n    filePath: z.string().min(1, \"filePath is required\"),\n    promptName: z.string().optional(),\n    includePrompt: z.boolean().default(true),\n    includeCode: z.boolean().default(true),\n    includeMetadata: z.boolean().default(true),\n    additionalContext: z.string().optional(),\n    encoding: z.string().default(\"utf8\"),\n  })\n  .strict();\n\ntype DocumentCodeArgs = z.infer<typeof documentCodeSchema>;\n\nconst codeChangeSchema = z\n  .object({\n    filePath: z.string().min(1, \"filePath is required\"),\n    patch: z.string().min(1, \"patch is required\"),\n    dryRun: z.boolean().default(false),\n    showDiff: z.boolean().default(true),\n    diffContext: z.number().int().min(0).max(100).default(3),\n    encoding: z.string().default(\"utf8\"),\n  })\n  .strict();\n\ntype ApplyCodeChangeArgs = z.infer<typeof codeChangeSchema>;\n\ntype DocPrompt = {\n  name: string;\n  title: string;\n  description: string;\n  content: string;\n  absolutePath: string;\n};\n\ntype WorkspaceResourceTemplate = {\n  name: string;\n  description: string;\n  uriTemplate: string;\n  mimeType: string;\n  arguments: ReadonlyArray<{\n    name: string;\n    description: string;\n    required: boolean;\n  }>;\n  load: (args: { path: string }) => Promise<{ text: string }>;\n};\n\nlet workspaceRoot = initializeWorkspaceRoot();\nlet userErrorCtor: (new (message: string) => Error) | undefined;\n\nclass WorkspaceError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"WorkspaceError\";\n  }\n}\n\nasync function getUserErrorCtor(): Promise<new (message: string) => Error> {\n  if (!userErrorCtor) {\n    try {\n      const mod = await import(\"fastmcp\");\n      userErrorCtor = (mod as { UserError: new (message: string) => Error })\n        .UserError;\n    } catch {\n      userErrorCtor = class MCPUserError extends Error {\n        constructor(message: string) {\n          super(message);\n          this.name = \"MCPUserError\";\n        }\n      };\n    }\n  }\n  return userErrorCtor;\n}\n\nasync function throwUserError(message: string): Promise<never> {\n  const Ctor = await getUserErrorCtor();\n  throw new Ctor(message);\n}\n\nconst documentCodeTool: Tool<undefined, typeof documentCodeSchema> = {\n  annotations: {\n    idempotentHint: true,\n    openWorldHint: false,\n    readOnlyHint: true,\n    title: \"Document Source File\",\n  },\n  description:\n    \"Generate documentation guidance for a file by combining repository prompts with the target source code.\",\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  execute: async (input, _context): Promise<ContentResult> => {\n    const args = documentCodeSchema.parse(input as DocumentCodeArgs);\n    const root = getWorkspaceRoot();\n    let filePath: string;\n    try {\n      filePath = resolveInWorkspace(root, args.filePath);\n    } catch (error) {\n      if (error instanceof WorkspaceError) {\n        return throwUserError(error.message);\n      }\n      /* istanbul ignore next */\n      throw error;\n    }\n\n    if (!fs.existsSync(filePath)) {\n      return throwUserError(`Cannot document missing file at ${args.filePath}`);\n    }\n\n    const fileContent = fs.readFileSync(filePath, {\n      encoding: args.encoding as BufferEncoding,\n    });\n    const prompts = discoverDocPrompts(root);\n\n    if (!prompts.length) {\n      return throwUserError(\n        \"No documentation prompts found under .code/prompts or .codex/prompts\"\n      );\n    }\n\n    const prompt = selectPrompt(\n      prompts,\n      args.promptName ?? DEFAULT_PROMPT_NAME\n    );\n\n    return buildDocumentationPayload({\n      filePath: args.filePath,\n      fileContent,\n      prompt,\n      includeCode: args.includeCode,\n      includePrompt: args.includePrompt,\n      includeMetadata: args.includeMetadata,\n      additionalContext: args.additionalContext,\n    });\n  },\n  name: \"document-code\",\n  parameters: documentCodeSchema,\n};\n\nconst applyCodeChangeTool: Tool<undefined, typeof codeChangeSchema> = {\n  annotations: {\n    destructiveHint: true,\n    idempotentHint: false,\n    openWorldHint: false,\n    readOnlyHint: false,\n    title: \"Apply Code Patch\",\n  },\n  description:\n    \"Apply a unified diff patch to a workspace file with optional dry-run validation and diff preview.\",\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  execute: async (input, _context): Promise<string | ContentResult> => {\n    const args = codeChangeSchema.parse(input as ApplyCodeChangeArgs);\n    const root = getWorkspaceRoot();\n    let filePath: string;\n    try {\n      filePath = resolveInWorkspace(root, args.filePath);\n    } catch (error) {\n      if (error instanceof WorkspaceError) {\n        return throwUserError(error.message);\n      }\n      throw error;\n    }\n\n    const original = fs.existsSync(filePath)\n      ? fs.readFileSync(filePath, args.encoding as BufferEncoding)\n      : \"\";\n\n    let patched: string | false;\n    try {\n      patched = applyPatch(original, args.patch);\n    } catch (error) {\n      return throwUserError(\n        `Failed to apply provided patch to ${args.filePath}: ${error instanceof Error ? error.message : error}`\n      );\n    }\n    /* istanbul ignore next */\n    if (patched === false) {\n      return throwUserError(\n        `Failed to apply provided patch to ${args.filePath}`\n      );\n    }\n\n    if (!args.dryRun) {\n      fs.mkdirSync(path.dirname(filePath), { recursive: true });\n      fs.writeFileSync(filePath, patched, {\n        encoding: args.encoding as BufferEncoding,\n      });\n    }\n\n    if (!args.showDiff) {\n      return `Patch ${args.dryRun ? \"validated\" : \"applied\"} for ${args.filePath}`;\n    }\n\n    const preview = createTwoFilesPatch(\n      args.filePath,\n      args.filePath,\n      original,\n      patched,\n      undefined,\n      undefined,\n      { context: args.diffContext }\n    );\n\n    return {\n      content: [\n        {\n          type: \"text\",\n          text: `Patch ${args.dryRun ? \"validated\" : \"applied\"} for ${args.filePath}`,\n        },\n        {\n          type: \"text\",\n          text: [\"```diff\", preview.trim(), \"```\"].join(\"\\n\"),\n        },\n      ],\n    } satisfies ContentResult;\n  },\n  name: \"apply-code-change\",\n  parameters: codeChangeSchema,\n};\n\nexport const tools = {\n  ...decoratorTools,\n  documentCodeTool,\n  applyCodeChangeTool,\n} as const;\n\nexport function enrich(mcp: FastMCP): FastMCP {\n  for (const prompt of buildDocPrompts()) {\n    mcp.addPrompt(prompt as any);\n  }\n\n  for (const tool of Object.values(tools)) {\n    mcp.addTool(tool as any);\n  }\n\n  for (const template of buildResourceTemplates()) {\n    mcp.addResourceTemplate(template as any);\n  }\n\n  return mcp;\n}\n\nexport default enrich;\nexport const PACKAGE_NAME = PKG;\nexport const VERSION = V;\n\nexport function setWorkspaceRoot(root: string) {\n  workspaceRoot = path.resolve(root);\n}\n\nexport function getWorkspaceRoot(): string {\n  return workspaceRoot;\n}\n\nexport function buildResourceTemplates(): WorkspaceResourceTemplate[] {\n  const root = getWorkspaceRoot();\n  const sharedArguments = [\n    {\n      name: \"path\",\n      description: \"Path relative to the workspace root\",\n      required: true,\n    },\n  ] as const;\n\n  return [\n    {\n      name: \"vscode-workspace-file\",\n      description:\n        \"Expose workspace files to Visual Studio Code via vscode:// URIs\",\n      uriTemplate: \"vscode://workspace/{path}\",\n      mimeType: \"text/plain\",\n      arguments: sharedArguments,\n      load: async (args: { path: string }) => {\n        const text = await readWorkspaceFile(root, args.path);\n        return { text };\n      },\n    },\n    {\n      name: \"cursor-workspace-file\",\n      description: \"Expose workspace files to Cursor via cursor:// URIs\",\n      uriTemplate: \"cursor://workspace/{path}\",\n      mimeType: \"text/plain\",\n      arguments: sharedArguments,\n      load: async (args: { path: string }) => {\n        const text = await readWorkspaceFile(root, args.path);\n        return { text };\n      },\n    },\n    {\n      name: \"copilot-workspace-file\",\n      description:\n        \"Expose workspace files to GitHub Copilot via copilot:// URIs\",\n      uriTemplate: \"copilot://workspace/{path}\",\n      mimeType: \"text/plain\",\n      arguments: sharedArguments,\n      load: async (args: { path: string }) => {\n        const text = await readWorkspaceFile(root, args.path);\n        return { text };\n      },\n    },\n  ];\n}\n\nfunction initializeWorkspaceRoot(): string {\n  const configured = process.env[WORKSPACE_ROOT_ENV];\n  if (configured && configured.trim().length > 0) {\n    return path.resolve(configured.trim());\n  }\n  return process.cwd();\n}\n\nexport function buildDocPrompts(): InputPrompt<undefined>[] {\n  const root = getWorkspaceRoot();\n  const fileBasedPrompts = discoverDocPrompts(root).map((prompt) => ({\n    name: `doc/${prompt.name}`,\n    description: prompt.description,\n    load: async () => prompt.content,\n  }));\n\n  const integrationPrompts = CLIENT_INTEGRATIONS.map<InputPrompt<undefined>>(\n    (integration) => ({\n      name: `integration/${integration.id}`,\n      description: `${integration.display} integration guidance`,\n      load: async () =>\n        `You are coordinating with ${integration.display}. ${integration.instructions}\\n\\nTools available:\\n- document-code\\n- apply-code-change\\n\\nEnsure responses include actionable steps for the client.`,\n    })\n  );\n\n  return [...fileBasedPrompts, ...integrationPrompts];\n}\n\nfunction resolveInWorkspace(root: string, targetPath: string): string {\n  const resolved = path.isAbsolute(targetPath)\n    ? path.normalize(targetPath)\n    : path.resolve(root, targetPath);\n\n  const relative = path.relative(root, resolved);\n  if (relative.startsWith(\"..\") || path.isAbsolute(relative)) {\n    throw new WorkspaceError(\n      `Path ${targetPath} escapes the workspace root at ${root}`\n    );\n  }\n\n  return resolved;\n}\n\nasync function readWorkspaceFile(\n  root: string,\n  target: string\n): Promise<string> {\n  try {\n    const absolute = resolveInWorkspace(root, target);\n    return fs.readFileSync(absolute, \"utf8\" as BufferEncoding);\n  } catch (error) {\n    if (error instanceof WorkspaceError) {\n      await throwUserError(error.message);\n    }\n    /* istanbul ignore next */\n    throw error;\n  }\n}\n\nfunction discoverDocPrompts(root: string): DocPrompt[] {\n  const discovered: DocPrompt[] = [];\n\n  for (const directory of PROMPT_DIRECTORIES) {\n    const promptDir = path.join(root, directory);\n    if (!fs.existsSync(promptDir) || !fs.statSync(promptDir).isDirectory()) {\n      continue;\n    }\n\n    for (const entry of fs.readdirSync(promptDir)) {\n      const fullPath = path.join(promptDir, entry);\n      if (!fs.statSync(fullPath).isFile()) continue;\n\n      const name = path.parse(entry).name;\n      const content = fs.readFileSync(fullPath, \"utf8\");\n      const title = toTitleCase(name.replace(/[-_]/g, \" \"));\n      const description = extractDescription(content, fullPath);\n\n      discovered.push({\n        name,\n        title,\n        description,\n        content,\n        absolutePath: fullPath,\n      });\n    }\n  }\n\n  const unique = new Map<string, DocPrompt>();\n  for (const prompt of discovered) {\n    if (!unique.has(prompt.name)) {\n      unique.set(prompt.name, prompt);\n    }\n  }\n\n  return Array.from(unique.values()).sort((a, b) =>\n    a.name.localeCompare(b.name)\n  );\n}\n\nfunction selectPrompt(prompts: DocPrompt[], requestedName: string): DocPrompt {\n  const direct = prompts.find((prompt) => prompt.name === requestedName);\n  if (direct) return direct;\n\n  const fallback = prompts.find(\n    (prompt) => prompt.name === DEFAULT_PROMPT_NAME\n  );\n  if (fallback) return fallback;\n\n  if (!prompts.length) {\n    throw new WorkspaceError(\"No documentation prompts available\");\n  }\n\n  return prompts[0];\n}\n\nfunction buildDocumentationPayload({\n  filePath,\n  fileContent,\n  prompt,\n  includePrompt,\n  includeCode,\n  includeMetadata,\n  additionalContext,\n}: {\n  filePath: string;\n  fileContent: string;\n  prompt: DocPrompt;\n  includePrompt: boolean;\n  includeCode: boolean;\n  includeMetadata: boolean;\n  additionalContext?: string;\n}): ContentResult {\n  const sections: string[] = [];\n\n  if (includeMetadata) {\n    sections.push(\n      `# Documentation Request\\n- prompt: ${prompt.name}\\n- file: ${filePath}`\n    );\n  }\n\n  if (includePrompt) {\n    sections.push(\n      `## Prompt Guidance (${prompt.title})\\n\\n${prompt.content.trim()}`\n    );\n  }\n\n  if (additionalContext?.trim()) {\n    sections.push(`## Additional Context\\n\\n${additionalContext.trim()}`);\n  }\n\n  if (includeCode) {\n    sections.push(\n      `## Source\\n\\n\\`\\`\\`${inferLanguageFromPath(filePath)}\\n${fileContent}\\n\\`\\`\\``\n    );\n  }\n\n  return {\n    content: [\n      {\n        type: \"text\",\n        text: sections.join(\"\\n\\n\"),\n      },\n    ],\n  } satisfies ContentResult;\n}\n\nfunction extractDescription(content: string, filePath: string): string {\n  const firstLine = content\n    .split(/\\r?\\n/)\n    .map((line) => line.trim())\n    .find((line) => line.length > 0);\n\n  return (\n    firstLine?.slice(0, 240) ??\n    `Documentation prompt loaded from ${path.basename(filePath)}`\n  );\n}\n\nfunction toTitleCase(value: string): string {\n  return value\n    .split(/\\s+/)\n    .filter(Boolean)\n    .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())\n    .join(\" \");\n}\n\nfunction inferLanguageFromPath(filePath: string): string {\n  const extension = path.extname(filePath).toLowerCase();\n  switch (extension) {\n    case \".ts\":\n    case \".tsx\":\n      return \"ts\";\n    case \".js\":\n    case \".jsx\":\n      return \"js\";\n    case \".json\":\n      return \"json\";\n    case \".md\":\n      return \"md\";\n    default:\n      return \"text\";\n  }\n}\n\nexport function __resetWorkspaceRoot(root: string) {\n  setWorkspaceRoot(root);\n}\n\nexport { documentCodeSchema, codeChangeSchema };\n","/**\n * @description The filename that identifies Decaf CLI modules\n * @summary The standard filename for CLI module files where each library must export a single CliModule function\n *\n * @const MCP_FILE_NAME\n * @memberOf module:MCP\n */\nexport const MCP_FILE_NAME = \"mcp-module\";\n","/* istanbul ignore file */\nimport path from \"path\";\nimport fs from \"fs\";\nimport { McpModule } from \"./types\";\n\n/**\n * @description Utility class for CLI operations\n * @summary A static utility class that provides methods for loading modules, retrieving package information, and initializing CLI commands\n *\n * @example\n * // Initialize a Command object with package information\n * const command = new Command();\n * CLIUtils.initialize(command, './path/to/package');\n *\n * // Load a CLI module from a file\n * const module = await CLIUtils.loadFromFile('./path/to/cli-module.js');\n *\n * @class McpUtils\n */\nexport class McpUtils {\n  /**\n   * @description Dynamically imports a module file\n   * @summary Loads a JavaScript file and returns it as a CliModule, handling both ESM and CommonJS formats\n   *\n   * @param {string} path The file path to the module to load\n   * @return {Promise<McpModule>} A promise that resolves to the loaded CliModule\n   */\n  static async loadFromFile(path: string): Promise<McpModule> {\n    try {\n      return McpUtils.normalizeImport(import(path));\n    } catch (e: unknown) {\n      throw new Error(\n        `Failed to load from ${path}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n  }\n\n  /**\n   * @description Normalizes module imports to handle both ESM and CommonJS formats\n   * @summary Properly imports JavaScript files regardless of their module format by handling the ESM wrapper for CommonJS modules\n   *\n   * @template T The type of the imported module\n   * @param {Promise<T>} importPromise The promise returned by the dynamic import\n   * @return {Promise<T>} A promise that resolves to the normalized module\n   * @private\n   */\n  static async normalizeImport<T>(importPromise: Promise<T>): Promise<T> {\n    // CommonJS's `module.exports` is wrapped as `default` in ESModule.\n    return importPromise.then(\n      (m: unknown) => ((m as { default: T }).default || m) as T\n    );\n  }\n\n  /**\n   * @description Retrieves and parses the package.json file\n   * @summary Reads the package.json file from the specified path and parses it into a JavaScript object\n   *\n   * @param {string} basePath The base path where the package.json file is located\n   * @return {Record<string, unknown>} The parsed package.json content as an object\n   * @private\n   */\n  private static getPackage(basePath: string): Record<string, unknown> {\n    try {\n      return JSON.parse(\n        fs.readFileSync(path.join(basePath, \"package.json\"), \"utf8\")\n      );\n    } catch (e: unknown) {\n      throw new Error(`Unable to read version from ${basePath}: ${e}`);\n    }\n  }\n\n  /**\n   * @description Returns the version from package.json\n   * @summary Retrieves the version field from the package.json file at the specified path\n   *\n   * @param {string} basePath The base path where the package.json file is located\n   * @return {string} The package version string\n   */\n  static packageVersion(basePath: string): string {\n    return McpUtils.getPackage(basePath)[\"version\"] as string;\n  }\n\n  /**\n   * @description Returns the name from package.json\n   * @summary Retrieves the name field from the package.json file at the specified path and extracts the package name without the scope\n   *\n   * @param {string} basePath The base path where the package.json file is located\n   * @return {string} The package name without the scope (e.g., \"cli\" from \"@decaf-ts/cli\")\n   */\n  static packageName(basePath: string): string {\n    const name = (McpUtils.getPackage(basePath)[\"name\"] as string).split(\"/\");\n    return name[name.length - 1];\n  }\n}\n","/* istanbul ignore file */\nimport fs from \"fs\";\nimport path from \"path\";\nimport { MCP_FILE_NAME } from \"./constants\";\nimport { McpUtils } from \"./utils\";\nimport { FastMCP } from \"fastmcp\";\nimport { LoggedClass } from \"@decaf-ts/logging\";\nimport { VERSION } from \"./metadata\";\n\n/**\n * @description Utility class to handle CLI functionality from all Decaf modules\n * @summary This class provides a wrapper around Commander.js to handle CLI commands from different Decaf modules.\n * It crawls the filesystem to find CLI modules, loads them, and registers their commands.\n *\n * @param {string} [basePath] The base path to look for modules in. Defaults to `./`\n * @param {number} [crawlLevels] Number of folder levels to crawl to find modules from the basePath. Defaults to 4\n *\n * @example\n * // Create a new CLI wrapper and run it with custom options\n * const cli = new CliWrapper('./src', 2);\n * cli.run(process.argv).then(() => {\n *   console.log('CLI commands executed successfully');\n * });\n *\n * @class McpWrapper\n */\nexport class McpWrapper extends LoggedClass {\n  private _mcp?: FastMCP;\n  private modules: Record<string, string> = {};\n  private readonly rootPath: string;\n\n  constructor(\n    private basePath: string = \"./\",\n    private crawlLevels = 4\n  ) {\n    super();\n    this.rootPath = path.resolve(__dirname, \"..\");\n  }\n\n  /**\n   * @description Retrieves and initializes the Commander Command object\n   * @summary Lazy-loads the Command object, initializing it with the package name, description, and version\n   * @return {Command} The initialized Command object\n   * @private\n   */\n  private get mcp() {\n    if (!this._mcp) {\n      this._mcp = new FastMCP({\n        name: \"decaf-ts MCP server\",\n        instructions: \"\",\n        version: VERSION as any,\n      });\n    }\n    return this._mcp;\n  }\n\n  /**\n   * @description Loads and registers an mcp extension module from a file\n   * @summary Dynamically imports an mcp extension module from the specified file path, initializes it, and registers it in the modules collection\n   *\n   */\n  private async load(\n    server: FastMCP,\n    filePath: string\n  ): Promise<{ mcp: FastMCP; package: string; version: string }> {\n    const log = this.log.for(this.load);\n\n    let pkg: string, version: string, enrich: any;\n    try {\n      const res = await McpUtils.loadFromFile(filePath);\n      pkg = res.PACKAGE_NAME;\n      version = res.VERSION;\n      enrich = res.enrich;\n    } catch (e: unknown) {\n      throw new Error((e as any).message || (e as any));\n    }\n    try {\n      log.info(`Enriching mcp server with module ${pkg} v${version}`);\n      const result = enrich(server);\n      server = result instanceof Promise ? await result : result;\n    } catch (e: unknown) {\n      throw new Error(\n        `failed to enrich mcp with module ${pkg || \"unnamed\"} under ${filePath}: ${e instanceof Error ? e.message : e}`\n      );\n    }\n    return {\n      mcp: server,\n      package: pkg,\n      version: version,\n    };\n  }\n\n  /**\n   * @description Finds and loads all CLI modules in the basePath\n   * @summary Uses the crawl method to find all CLI modules in the specified base path,\n   * then loads and registers each module as a subcommand\n   *\n   * @return {Promise<void>} A promise that resolves when all modules are loaded\n   *\n   * @private\n   * @mermaid\n   * sequenceDiagram\n   *   participant CliWrapper\n   *   participant Filesystem\n   *   participant Module\n   *\n   *   CliWrapper->>Filesystem: Join basePath with cwd\n   *   CliWrapper->>CliWrapper: crawl(basePath, crawlLevels)\n   *   CliWrapper-->>CliWrapper: modules[]\n   *   loop For each module\n   *     alt Not @decaf-ts/cli\n   *       CliWrapper->>CliWrapper: load(module, cwd)\n   *       CliWrapper-->>CliWrapper: name\n   *       CliWrapper->>CliWrapper: Check if command exists\n   *       alt Command doesn't exist\n   *         CliWrapper->>Command: command(name).addCommand(modules[name])\n   *       end\n   *     end\n   *   end\n   *   CliWrapper->>Console: Log loaded modules\n   */\n  private async boot() {\n    const log = this.log.for(this.boot);\n\n    const basePath = path.resolve(this.rootPath, this.basePath);\n    const modules = this.crawl(basePath, this.crawlLevels);\n    let server = this.mcp;\n    for (const module of modules) {\n      if (module.includes(\"@decaf-ts/mcp\")) {\n        continue;\n      }\n      try {\n        const res = await this.load(server, module);\n        server = res.mcp;\n      } catch (e: unknown) {\n        log.error(`Failed to load MCP configs for ${module}: ${e}`);\n      }\n    }\n    console.log(\n      `loaded modules:\\n${Object.keys(this.modules)\n        .map((k) => `- ${k}`)\n        .join(\"\\n\")}`\n    );\n    return server;\n  }\n\n  /**\n   * @description Recursively searches for CLI module files in the directory structure\n   * @summary Crawls the basePath up to the specified number of folder levels to find files named according to CLI_FILE_NAME\n   *\n   * @param {string} basePath The absolute base path to start searching in\n   * @param {number} [levels=2] The maximum number of directory levels to crawl\n   * @return {string[]} An array of file paths to CLI modules\n   *\n   * @private\n   */\n  private crawl(basePath: string, levels: number = 2) {\n    if (levels <= 0) return [];\n    return fs.readdirSync(basePath).reduce((accum: string[], file) => {\n      file = path.join(basePath, file);\n      if (fs.statSync(file).isDirectory()) {\n        accum.push(...this.crawl(file, levels - 1));\n      } else if (file.match(new RegExp(`${MCP_FILE_NAME}.[cm]?js$`, \"gm\"))) {\n        accum.push(file);\n      }\n      return accum;\n    }, []);\n  }\n\n  /**\n   * @description Executes the CLI with the provided arguments\n   * @summary Boots the CLI by loading all modules, then parses and executes the command specified in the arguments\n   *\n   * @param {string[]} [args=process.argv] Command line arguments to parse and execute\n   * @return {Promise<void>} A promise that resolves when the command execution is complete\n   *\n   * @mermaid\n   * sequenceDiagram\n   *   participant Client\n   *   participant CliWrapper\n   *   participant Command\n   *\n   *   Client->>CliWrapper: run(args)\n   *   CliWrapper->>CliWrapper: boot()\n   *   Note over CliWrapper: Loads all modules\n   *   CliWrapper->>Command: parseAsync(args)\n   *   Command-->>CliWrapper: result\n   *   CliWrapper-->>Client: result\n   */\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  async run(args: string[] = process.argv) {\n    const server = await this.boot();\n    await server.start({ transportType: \"stdio\" });\n  }\n}\n"],"names":["VERSION","PACKAGE_NAME","PKG","V"],"mappings":";;;;;;;;AAEA;;;;;;AAMG;AACI,MAAMA,SAAO,GAAG,aAAa;AAC7B,MAAMC,cAAY,GAAG,kBAAkB;AAE9C,IAAI;AACF,IAAA,QAAQ,CAAC,eAAe,CAACA,cAAY,EAAED,SAAO,CAAC;AACjD;AAAE,OAAO,KAAK,EAAE;AACd,IAAA,IAAI,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE;SAE1D;AACL,QAAA,MAAM,KAAK;;AAEf;;ACNA,SAAS,YAAY,CAAC,KAAa,EAAA;IACjC,OAAO,KAAK,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC;AACrD;AAEA,SAAS,eAAe,CAAC,IAAmB,EAAA;AAC1C,IAAA,MAAM,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE,EAAE,GAAG,CAAC,CAAC,GAAG,KAAK,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;AAC3E,IAAA,OAAO,IAAI,IAAI,CAAC,IAAI,CAAI,CAAA,EAAA,IAAI,GAAG;AACjC;AAEA,SAAS,eAAe,CAAC,QAAgB,EAAA;AACvC,IAAA,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;AAC3D;AAEA,SAAS,qBAAqB,CAC5B,eAA4C,EAC5C,UAAuC,EAAA;AAEvC,IAAA,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU;AAC/B,IAAA,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC;AAClB,IAAA,KAAK,MAAM,SAAS,IAAI,eAAe,IAAI,EAAE,EAAE;AAC7C,QAAA,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC;;AAE3B,IAAA,KAAK,MAAM,QAAQ,IAAI,UAAU,IAAI,EAAE,EAAE;QACvC,KAAK,MAAM,SAAS,IAAI,QAAQ,CAAC,UAAU,IAAI,EAAE,EAAE;AACjD,YAAA,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC;;;AAG7B,IAAA,OAAO,KAAK;AACd;AAEA,SAAS,YAAY,CACnB,OAAe,EACf,WAAmB,EACnB,UAAuB,EAAA;;IAGvB,IAAI,CAAC,UAAU,CAAC,IAAI;AAAE,QAAA,OAAO,OAAO;AACpC,IAAA,MAAM,WAAW,GAAG,IAAI,MAAM,CAC5B,CAAA,uCAAA,EAA0C,YAAY,CAAC,WAAW,CAAC,CAAO,KAAA,CAAA,CAC3E;IACD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,WAAW,CAAC;IACxC,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,IAAI,EAAE;IAE5C,IAAI,KAAK,EAAE;AACT,QAAA,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC;aACrB,KAAK,CAAC,GAAG;aACT,GAAG,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE;aACzB,MAAM,CAAC,OAAO,CAAC;QAClB,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,QAAQ,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;AACnE,QAAA,OAAO,OAAO,CAAC,OAAO,CACpB,WAAW,EACX,CAAY,SAAA,EAAA,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,WAAW,CAAA,EAAA,CAAI,CACzD;;AAGH,IAAA,MAAM,UAAU,GAAG,CAAY,SAAA,EAAA,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA,SAAA,EAAY,WAAW,CAAA,EAAA,CAAI;AAC3E,IAAA,OAAO,CAAG,EAAA,UAAU,CAAO,IAAA,EAAA,OAAO,EAAE;AACtC;AAEA,SAAS,gBAAgB,CAAC,QAAuB,EAAA;IAC/C,MAAM,UAAU,GAAG,CAAC,QAAQ,CAAC,UAAU,IAAI,EAAE;SAC1C,GAAG,CAAC,eAAe;SACnB,IAAI,CAAC,MAAM,CAAC;AACf,IAAA,MAAM,cAAc,GAAG,UAAU,GAAG,CAAK,EAAA,EAAA,UAAU,CAAI,EAAA,CAAA,GAAG,EAAE;IAC5D,OAAO,CAAA,EAAG,cAAc,CAAA,EAAA,EAAK,QAAQ,CAAC,IAAI,CAAA,EAAA,EAAK,QAAQ,CAAC,IAAI,CAAA,CAAA,CAAG;AACjE;AAEA,SAAS,mBAAmB,CAAC,OAAe,EAAE,YAAoB,EAAA;IAChE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC;IACpC,MAAM,MAAM,GAAa,EAAE;AAC3B,IAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACrC,QAAA,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC;QACrB,IACE,IAAI,CAAC,IAAI,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC;AAC3B,YAAA,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAG,EAAA,YAAY,CAAG,CAAA,CAAA,CAAC,EAC1C;YACA;;QAEF,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,YAAY,CAAA,CAAA,CAAG,CAAC,EAAE;;YAErC;;AAEF,QAAA,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;;AAEnB,IAAA,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;AAC1B;AAEA,SAAS,eAAe,CACtB,OAAe,EACf,SAAwB,EACxB,MAGC,EAAA;AAED,IAAA,MAAM,aAAa,GAAG,eAAe,CAAC,SAAS,CAAC;AAChD,IAAA,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE;QAC3B,MAAM,UAAU,GAAG,iCAAiC;AACpD,QAAA,IAAI,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;AAAE,YAAA,OAAO,OAAO;QACnD,OAAO,OAAO,CAAC,OAAO,CAAC,UAAU,EAAE,CAAG,EAAA,aAAa,CAAM,IAAA,CAAA,CAAC;;IAE5D,IAAI,CAAC,MAAM,CAAC,IAAI;AAAE,QAAA,OAAO,OAAO;AAChC,IAAA,MAAM,aAAa,GAAG,IAAI,MAAM,CAC9B,wBAAwB,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA,CAAA,CAAG,EACpD,GAAG,CACJ;IACD,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC;AACzC,IAAA,IAAI,CAAC,KAAK;AAAE,QAAA,OAAO,OAAO;IAC1B,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI;IAC/B,IAAI,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAA,EAAG,aAAa,CAAA,CAAE,CAAC;AAAE,QAAA,OAAO,OAAO;IACjE,QACE,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC;QAC7B,CAAG,EAAA,MAAM,CAAG,EAAA,aAAa,CAAI,EAAA,CAAA;QAC7B,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC;AAE9B;AAEA,SAAS,eAAe,CACtB,OAAe,EACf,aAAqB,EACrB,MAGC,EAAA;AAED,IAAA,MAAM,cAAc,GAAG,IAAI,MAAM,CAC/B,CAAS,MAAA,EAAA,YAAY,CAAC,aAAa,CAAC,CAAA,WAAA,CAAa,EACjD,GAAG,CACJ;AACD,IAAA,IAAI,MAAM,CAAC,IAAI,KAAK,OAAO,EAAE;QAC3B,OAAO,OAAO,CAAC,OAAO,CAAC,cAAc,EAAE,EAAE,CAAC;;AAE5C,IAAA,IAAI,MAAM,CAAC,IAAI,EAAE;QACf,MAAM,OAAO,GAAG,IAAI,MAAM,CACxB,CAAU,OAAA,EAAA,YAAY,CAAC,aAAa,CAAC,8BAA8B,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAI,EAAA,CAAA,EAChG,GAAG,CACJ;QACD,OAAO,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;;AAErC,IAAA,OAAO,OAAO;AAChB;AAEA,SAAS,cAAc,CAAC,QAAgB,EAAE,OAAe,EAAA;IACvD,eAAe,CAAC,QAAQ,CAAC;AACzB,IAAA,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,CAAC;AACrC;AAEO,MAAM,cAAc,GAAG;AAC5B,IAAA,uBAAuB,EAAE;AACvB,QAAA,IAAI,EAAE,wBAAwB;AAC9B,QAAA,WAAW,EAAE,iDAAiD;AAC9D,QAAA,OAAO,EAAE,OAAO,IAOf,KAAI;AACH,YAAA,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;gBACnD,MAAM,IAAI,KAAK,CAAC,CAAA,uBAAA,EAA0B,IAAI,CAAC,QAAQ,CAAE,CAAA,CAAC;;AAE5D,YAAA,MAAM,UAAU,GAAG,qBAAqB,CACtC,IAAI,CAAC,eAAe,EACpB,IAAI,CAAC,UAAU,CAChB;YACD,IAAI,OAAO,GAAG,CAAA,QAAA,CAAU;YACxB,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,eAAe,IAAI,EAAE,EAAE;AAClD,gBAAA,OAAO,IAAI,CAAK,EAAA,EAAA,eAAe,CAAC,SAAS,CAAC,EAAE;;YAE9C,MAAM,UAAU,GAAG,CAAC,IAAI,CAAC,UAAU,IAAI,EAAE;iBACtC,GAAG,CAAC,gBAAgB;iBACpB,IAAI,CAAC,MAAM,CAAC;AACf,YAAA,OAAO,IAAI,CAAkB,eAAA,EAAA,IAAI,CAAC,SAAS,CAAA,IAAA,EAAO,UAAU,GAAG,CAAA,EAAG,UAAU,CAAI,EAAA,CAAA,GAAG,EAAE,KAAK;YAC1F,OAAO,GAAG,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC;AAC7D,YAAA,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC;AACtC,YAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;SACnC;AACF,KAAA;AACD,IAAA,gBAAgB,EAAE;AAChB,QAAA,IAAI,EAAE,eAAe;AACrB,QAAA,WAAW,EAAE,gDAAgD;AAC7D,QAAA,OAAO,EAAE,OAAO,IAKf,KAAI;YACH,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;gBACjC,MAAM,IAAI,KAAK,CAAC,CAAA,wBAAA,EAA2B,IAAI,CAAC,QAAQ,CAAE,CAAA,CAAC;;AAE7D,YAAA,IAAI,OAAO,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC;AACpD,YAAA,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAG,EAAA,IAAI,CAAC,SAAS,CAAC,IAAI,CAAG,CAAA,CAAA,CAAC,EAAE;AAC/C,gBAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;;AAEpC,YAAA,MAAM,UAAU,GAAG,qBAAqB,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACrE,OAAO,GAAG,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC;YAC7D,MAAM,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC;YAC/C,MAAM,KAAK,GAAG,gBAAgB,CAAC,IAAI,CAAC,SAAS,CAAC;AAC9C,YAAA,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,cAAc,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;YACnE,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,cAAc,CAAC;YAC3C,MAAM,OAAO,GAAG,CAAG,EAAA,MAAM,KAAK,KAAK,CAAA,EAAA,EAAK,KAAK,CAAA,CAAE;AAC/C,YAAA,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC;AACtC,YAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;SACnC;AACF,KAAA;AACD,IAAA,mBAAmB,EAAE;AACnB,QAAA,IAAI,EAAE,kBAAkB;AACxB,QAAA,WAAW,EAAE,wCAAwC;AACrD,QAAA,OAAO,EAAE,OAAO,IAIf,KAAI;YACH,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC;AAAE,gBAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;AACrE,YAAA,MAAM,OAAO,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC;YACtD,MAAM,OAAO,GAAG,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,CAAC;AAChE,YAAA,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC;AACtC,YAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;SACnC;AACF,KAAA;AACD,IAAA,kBAAkB,EAAE;AAClB,QAAA,IAAI,EAAE,iBAAiB;AACvB,QAAA,WAAW,EAAE,0CAA0C;AACvD,QAAA,OAAO,EAAE,OAAO,IAMf,KAAI;YACH,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE;gBACjC,MAAM,IAAI,KAAK,CAAC,CAAA,wBAAA,EAA2B,IAAI,CAAC,QAAQ,CAAE,CAAA,CAAC;;AAE7D,YAAA,IAAI,OAAO,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC;AACpD,YAAA,MAAM,UAAU,GAAG,IAAI,GAAG,CAAS,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YACzD,OAAO,GAAG,YAAY,CAAC,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,UAAU,CAAC;AAC7D,YAAA,OAAO,GAAG,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,MAAM,CAAC;AAC/D,YAAA,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC;AACtC,YAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;SACnC;AACF,KAAA;AACD,IAAA,mBAAmB,EAAE;AACnB,QAAA,IAAI,EAAE,kBAAkB;AACxB,QAAA,WAAW,EAAE,6CAA6C;AAC1D,QAAA,OAAO,EAAE,OAAO,IAKf,KAAI;YACH,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC;AAAE,gBAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;AACrE,YAAA,IAAI,OAAO,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,QAAQ,EAAE,MAAM,CAAC;AACpD,YAAA,OAAO,GAAG,eAAe,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,IAAI,CAAC,MAAM,CAAC;AACnE,YAAA,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC;AACtC,YAAA,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;SACnC;AACF,KAAA;AACD,IAAA,qBAAqB,EAAE;AACrB,QAAA,IAAI,EAAE,oBAAoB;AAC1B,QAAA,WAAW,EAAE,mDAAmD;AAChE,QAAA,OAAO,EAAE,OAAO,IAIf,KAAI;AACH,YAAA,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,GAAG,IAAI,CAAC,IAAI,CAAA,GAAA,CAAK,CAAC;YAClE,eAAe,CAAC,SAAS,CAAC;AAC1B,YAAA,MAAM,YAAY,GAAG,CAAA,aAAA,EAAgB,IAAI,CAAC,IAAI,sFAAsF;AACpI,YAAA,EAAE,CAAC,aAAa,CAAC,SAAS,EAAE,YAAY,CAAC;AACzC,YAAA,IAAI,aAAiC;AACrC,YAAA,IAAI,IAAI,CAAC,YAAY,EAAE;AACrB,gBAAA,aAAa,GAAG,IAAI,CAAC,IAAI,CACvB,IAAI,CAAC,YAAY,EACjB,GAAG,IAAI,CAAC,IAAI,CAAA,YAAA,CAAc,CAC3B;gBACD,eAAe,CAAC,aAAa,CAAC;gBAC9B,EAAE,CAAC,aAAa,CACd,aAAa,EACb,CAAmB,gBAAA,EAAA,IAAI,CAAC,IAAI,CAA4C,0CAAA,CAAA,CACzE;;AAEH,YAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE;SACpC;AACF,KAAA;AACD,IAAA,sBAAsB,EAAE;AACtB,QAAA,IAAI,EAAE,qBAAqB;AAC3B,QAAA,WAAW,EAAE,mDAAmD;AAChE,QAAA,OAAO,EAAE,OAAO,IAKf,KAAI;AACH,YAAA,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,IAAI,CAAA,GAAA,CAAK,CAAC;YACxD,eAAe,CAAC,SAAS,CAAC;YAC1B,EAAE,CAAC,aAAa,CACd,SAAS,EACT,CAAgB,aAAA,EAAA,IAAI,CAAC,IAAI,CAAwF,sFAAA,CAAA,CAClH;AACD,YAAA,IAAI,YAAgC;AACpC,YAAA,IAAI,IAAI,CAAC,WAAW,EAAE;AACpB,gBAAA,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,IAAI,CAAA,WAAA,CAAa,CAAC;gBACrE,eAAe,CAAC,YAAY,CAAC;gBAC7B,EAAE,CAAC,aAAa,CACd,YAAY,EACZ,CAA2B,wBAAA,EAAA,IAAI,CAAC,IAAI,CAAkB,eAAA,EAAA,IAAI,CAAC,UAAU,GAAG,WAAW,GAAG,YAAY,CAAQ,MAAA,CAAA,CAC3G;;AAEH,YAAA,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE;SACnC;AACF,KAAA;AACD,IAAA,mBAAmB,EAAE;AACnB,QAAA,IAAI,EAAE,kBAAkB;AACxB,QAAA,WAAW,EAAE,mDAAmD;AAChE,QAAA,OAAO,EAAE,OAAO,IAKf,KAAI;AACH,YAAA,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,IAAI,CAAA,GAAA,CAAK,CAAC;YAC3D,eAAe,CAAC,YAAY,CAAC;YAC7B,EAAE,CAAC,aAAa,CACd,YAAY,EACZ,CAAmB,gBAAA,EAAA,IAAI,CAAC,IAAI,CAA8E,4EAAA,CAAA,CAC3G;AACD,YAAA,IAAI,YAAgC;AACpC,YAAA,IAAI,IAAI,CAAC,WAAW,EAAE;AACpB,gBAAA,YAAY,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,IAAI,CAAA,WAAA,CAAa,CAAC;gBACrE,eAAe,CAAC,YAAY,CAAC;gBAC7B,EAAE,CAAC,aAAa,CACd,YAAY,EACZ,CAA2B,wBAAA,EAAA,IAAI,CAAC,IAAI,CAAkB,eAAA,EAAA,IAAI,CAAC,UAAU,GAAG,WAAW,GAAG,YAAY,CAAQ,MAAA,CAAA,CAC3G;;AAEH,YAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE;SACtC;AACF,KAAA;CACO;;ACzVV,MAAM,kBAAkB,GAAG,oBAAoB;AAC/C,MAAM,kBAAkB,GAAG,CAAC,eAAe,EAAE,gBAAgB,CAAC;AAC9D,MAAM,mBAAmB,GAAG,KAAK;AACjC,MAAM,mBAAmB,GAAG;AAC1B,IAAA;AACE,QAAA,EAAE,EAAE,QAAQ;AACZ,QAAA,OAAO,EAAE,oBAAoB;AAC7B,QAAA,YAAY,EACV,oMAAoM;AACvM,KAAA;AACD,IAAA;AACE,QAAA,EAAE,EAAE,QAAQ;AACZ,QAAA,OAAO,EAAE,QAAQ;AACjB,QAAA,YAAY,EACV,iLAAiL;AACpL,KAAA;AACD,IAAA;AACE,QAAA,EAAE,EAAE,SAAS;AACb,QAAA,OAAO,EAAE,gBAAgB;AACzB,QAAA,YAAY,EACV,iMAAiM;AACpM,KAAA;CACO;AAEV,MAAM,kBAAkB,GAAG;AACxB,KAAA,MAAM,CAAC;IACN,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,sBAAsB,CAAC;AACnD,IAAA,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACjC,aAAa,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IACxC,WAAW,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IACtC,eAAe,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;AAC1C,IAAA,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACxC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;CACrC;AACA,KAAA,MAAM,EAAE;AAIX,MAAM,gBAAgB,GAAG;AACtB,KAAA,MAAM,CAAC;IACN,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,sBAAsB,CAAC;IACnD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,mBAAmB,CAAC;IAC7C,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC;IAClC,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC;IACnC,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC;IACxD,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,MAAM,CAAC;CACrC;AACA,KAAA,MAAM,EAAE;AAyBX,IAAI,aAAa,GAAG,uBAAuB,EAAE;AAC7C,IAAI,aAA2D;AAE/D,MAAM,cAAe,SAAQ,KAAK,CAAA;AAChC,IAAA,WAAA,CAAY,OAAe,EAAA;QACzB,KAAK,CAAC,OAAO,CAAC;AACd,QAAA,IAAI,CAAC,IAAI,GAAG,gBAAgB;;AAE/B;AAED,eAAe,gBAAgB,GAAA;IAC7B,IAAI,CAAC,aAAa,EAAE;AAClB,QAAA,IAAI;AACF,YAAA,MAAM,GAAG,GAAG,MAAM,OAAO,SAAS,CAAC;AACnC,YAAA,aAAa,GAAI;AACd,iBAAA,SAAS;;AACZ,QAAA,MAAM;AACN,YAAA,aAAa,GAAG,MAAM,YAAa,SAAQ,KAAK,CAAA;AAC9C,gBAAA,WAAA,CAAY,OAAe,EAAA;oBACzB,KAAK,CAAC,OAAO,CAAC;AACd,oBAAA,IAAI,CAAC,IAAI,GAAG,cAAc;;aAE7B;;;AAGL,IAAA,OAAO,aAAa;AACtB;AAEA,eAAe,cAAc,CAAC,OAAe,EAAA;AAC3C,IAAA,MAAM,IAAI,GAAG,MAAM,gBAAgB,EAAE;AACrC,IAAA,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC;AACzB;AAEA,MAAM,gBAAgB,GAA+C;AACnE,IAAA,WAAW,EAAE;AACX,QAAA,cAAc,EAAE,IAAI;AACpB,QAAA,aAAa,EAAE,KAAK;AACpB,QAAA,YAAY,EAAE,IAAI;AAClB,QAAA,KAAK,EAAE,sBAAsB;AAC9B,KAAA;AACD,IAAA,WAAW,EACT,yGAAyG;;AAE3G,IAAA,OAAO,EAAE,OAAO,KAAK,EAAE,QAAQ,KAA4B;QACzD,MAAM,IAAI,GAAG,kBAAkB,CAAC,KAAK,CAAC,KAAyB,CAAC;AAChE,QAAA,MAAM,IAAI,GAAG,gBAAgB,EAAE;AAC/B,QAAA,IAAI,QAAgB;AACpB,QAAA,IAAI;YACF,QAAQ,GAAG,kBAAkB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC;;QAClD,OAAO,KAAK,EAAE;AACd,YAAA,IAAI,KAAK,YAAY,cAAc,EAAE;AACnC,gBAAA,OAAO,cAAc,CAAC,KAAK,CAAC,OAAO,CAAC;;;AAGtC,YAAA,MAAM,KAAK;;QAGb,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE;YAC5B,OAAO,cAAc,CAAC,CAAmC,gCAAA,EAAA,IAAI,CAAC,QAAQ,CAAA,CAAE,CAAC;;AAG3E,QAAA,MAAM,WAAW,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE;YAC5C,QAAQ,EAAE,IAAI,CAAC,QAA0B;AAC1C,SAAA,CAAC;AACF,QAAA,MAAM,OAAO,GAAG,kBAAkB,CAAC,IAAI,CAAC;AAExC,QAAA,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;AACnB,YAAA,OAAO,cAAc,CACnB,sEAAsE,CACvE;;AAGH,QAAA,MAAM,MAAM,GAAG,YAAY,CACzB,OAAO,EACP,IAAI,CAAC,UAAU,IAAI,mBAAmB,CACvC;AAED,QAAA,OAAO,yBAAyB,CAAC;YAC/B,QAAQ,EAAE,IAAI,CAAC,QAAQ;YACvB,WAAW;YACX,MAAM;YACN,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,eAAe,EAAE,IAAI,CAAC,eAAe;YACrC,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;AAC1C,SAAA,CAAC;KACH;AACD,IAAA,IAAI,EAAE,eAAe;AACrB,IAAA,UAAU,EAAE,kBAAkB;CAC/B;AAED,MAAM,mBAAmB,GAA6C;AACpE,IAAA,WAAW,EAAE;AACX,QAAA,eAAe,EAAE,IAAI;AACrB,QAAA,cAAc,EAAE,KAAK;AACrB,QAAA,aAAa,EAAE,KAAK;AACpB,QAAA,YAAY,EAAE,KAAK;AACnB,QAAA,KAAK,EAAE,kBAAkB;AAC1B,KAAA;AACD,IAAA,WAAW,EACT,mGAAmG;;AAErG,IAAA,OAAO,EAAE,OAAO,KAAK,EAAE,QAAQ,KAAqC;QAClE,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,CAAC,KAA4B,CAAC;AACjE,QAAA,MAAM,IAAI,GAAG,gBAAgB,EAAE;AAC/B,QAAA,IAAI,QAAgB;AACpB,QAAA,IAAI;YACF,QAAQ,GAAG,kBAAkB,CAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC;;QAClD,OAAO,KAAK,EAAE;AACd,YAAA,IAAI,KAAK,YAAY,cAAc,EAAE;AACnC,gBAAA,OAAO,cAAc,CAAC,KAAK,CAAC,OAAO,CAAC;;AAEtC,YAAA,MAAM,KAAK;;AAGb,QAAA,MAAM,QAAQ,GAAG,EAAE,CAAC,UAAU,CAAC,QAAQ;cACnC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,QAA0B;cACzD,EAAE;AAEN,QAAA,IAAI,OAAuB;AAC3B,QAAA,IAAI;YACF,OAAO,GAAG,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,KAAK,CAAC;;QAC1C,OAAO,KAAK,EAAE;YACd,OAAO,cAAc,CACnB,CAAqC,kCAAA,EAAA,IAAI,CAAC,QAAQ,CAAA,EAAA,EAAK,KAAK,YAAY,KAAK,GAAG,KAAK,CAAC,OAAO,GAAG,KAAK,CAAE,CAAA,CACxG;;;AAGH,QAAA,IAAI,OAAO,KAAK,KAAK,EAAE;YACrB,OAAO,cAAc,CACnB,CAAqC,kCAAA,EAAA,IAAI,CAAC,QAAQ,CAAA,CAAE,CACrD;;AAGH,QAAA,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;AAChB,YAAA,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC;AACzD,YAAA,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE;gBAClC,QAAQ,EAAE,IAAI,CAAC,QAA0B;AAC1C,aAAA,CAAC;;AAGJ,QAAA,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;AAClB,YAAA,OAAO,SAAS,IAAI,CAAC,MAAM,GAAG,WAAW,GAAG,SAAS,CAAA,KAAA,EAAQ,IAAI,CAAC,QAAQ,EAAE;;AAG9E,QAAA,MAAM,OAAO,GAAG,mBAAmB,CACjC,IAAI,CAAC,QAAQ,EACb,IAAI,CAAC,QAAQ,EACb,QAAQ,EACR,OAAO,EACP,SAAS,EACT,SAAS,EACT,EAAE,OAAO,EAAE,IAAI,CAAC,WAAW,EAAE,CAC9B;QAED,OAAO;AACL,YAAA,OAAO,EAAE;AACP,gBAAA;AACE,oBAAA,IAAI,EAAE,MAAM;AACZ,oBAAA,IAAI,EAAE,CAAS,MAAA,EAAA,IAAI,CAAC,MAAM,GAAG,WAAW,GAAG,SAAS,QAAQ,IAAI,CAAC,QAAQ,CAAE,CAAA;AAC5E,iBAAA;AACD,gBAAA;AACE,oBAAA,IAAI,EAAE,MAAM;AACZ,oBAAA,IAAI,EAAE,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,EAAE,EAAE,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;AACpD,iBAAA;AACF,aAAA;SACsB;KAC1B;AACD,IAAA,IAAI,EAAE,mBAAmB;AACzB,IAAA,UAAU,EAAE,gBAAgB;CAC7B;AAEY,MAAA,KAAK,GAAG;AACnB,IAAA,GAAG,cAAc;IACjB,gBAAgB;IAChB,mBAAmB;;AAGf,SAAU,MAAM,CAAC,GAAY,EAAA;AACjC,IAAA,KAAK,MAAM,MAAM,IAAI,eAAe,EAAE,EAAE;AACtC,QAAA,GAAG,CAAC,SAAS,CAAC,MAAa,CAAC;;IAG9B,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE;AACvC,QAAA,GAAG,CAAC,OAAO,CAAC,IAAW,CAAC;;AAG1B,IAAA,KAAK,MAAM,QAAQ,IAAI,sBAAsB,EAAE,EAAE;AAC/C,QAAA,GAAG,CAAC,mBAAmB,CAAC,QAAe,CAAC;;AAG1C,IAAA,OAAO,GAAG;AACZ;AAGO,MAAM,YAAY,GAAGE;AACrB,MAAM,OAAO,GAAGC;AAEjB,SAAU,gBAAgB,CAAC,IAAY,EAAA;AAC3C,IAAA,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;AACpC;SAEgB,gBAAgB,GAAA;AAC9B,IAAA,OAAO,aAAa;AACtB;SAEgB,sBAAsB,GAAA;AACpC,IAAA,MAAM,IAAI,GAAG,gBAAgB,EAAE;AAC/B,IAAA,MAAM,eAAe,GAAG;AACtB,QAAA;AACE,YAAA,IAAI,EAAE,MAAM;AACZ,YAAA,WAAW,EAAE,qCAAqC;AAClD,YAAA,QAAQ,EAAE,IAAI;AACf,SAAA;KACO;IAEV,OAAO;AACL,QAAA;AACE,YAAA,IAAI,EAAE,uBAAuB;AAC7B,YAAA,WAAW,EACT,iEAAiE;AACnE,YAAA,WAAW,EAAE,2BAA2B;AACxC,YAAA,QAAQ,EAAE,YAAY;AACtB,YAAA,SAAS,EAAE,eAAe;AAC1B,YAAA,IAAI,EAAE,OAAO,IAAsB,KAAI;gBACrC,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;gBACrD,OAAO,EAAE,IAAI,EAAE;aAChB;AACF,SAAA;AACD,QAAA;AACE,YAAA,IAAI,EAAE,uBAAuB;AAC7B,YAAA,WAAW,EAAE,qDAAqD;AAClE,YAAA,WAAW,EAAE,2BAA2B;AACxC,YAAA,QAAQ,EAAE,YAAY;AACtB,YAAA,SAAS,EAAE,eAAe;AAC1B,YAAA,IAAI,EAAE,OAAO,IAAsB,KAAI;gBACrC,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;gBACrD,OAAO,EAAE,IAAI,EAAE;aAChB;AACF,SAAA;AACD,QAAA;AACE,YAAA,IAAI,EAAE,wBAAwB;AAC9B,YAAA,WAAW,EACT,8DAA8D;AAChE,YAAA,WAAW,EAAE,4BAA4B;AACzC,YAAA,QAAQ,EAAE,YAAY;AACtB,YAAA,SAAS,EAAE,eAAe;AAC1B,YAAA,IAAI,EAAE,OAAO,IAAsB,KAAI;gBACrC,MAAM,IAAI,GAAG,MAAM,iBAAiB,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC;gBACrD,OAAO,EAAE,IAAI,EAAE;aAChB;AACF,SAAA;KACF;AACH;AAEA,SAAS,uBAAuB,GAAA;IAC9B,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC;IAClD,IAAI,UAAU,IAAI,UAAU,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,CAAC,EAAE;QAC9C,OAAO,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC;;AAExC,IAAA,OAAO,OAAO,CAAC,GAAG,EAAE;AACtB;SAEgB,eAAe,GAAA;AAC7B,IAAA,MAAM,IAAI,GAAG,gBAAgB,EAAE;AAC/B,IAAA,MAAM,gBAAgB,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,MAAM,MAAM;AACjE,QAAA,IAAI,EAAE,CAAA,IAAA,EAAO,MAAM,CAAC,IAAI,CAAE,CAAA;QAC1B,WAAW,EAAE,MAAM,CAAC,WAAW;AAC/B,QAAA,IAAI,EAAE,YAAY,MAAM,CAAC,OAAO;AACjC,KAAA,CAAC,CAAC;IAEH,MAAM,kBAAkB,GAAG,mBAAmB,CAAC,GAAG,CAChD,CAAC,WAAW,MAAM;AAChB,QAAA,IAAI,EAAE,CAAA,YAAA,EAAe,WAAW,CAAC,EAAE,CAAE,CAAA;AACrC,QAAA,WAAW,EAAE,CAAA,EAAG,WAAW,CAAC,OAAO,CAAuB,qBAAA,CAAA;AAC1D,QAAA,IAAI,EAAE,YACJ,CAAA,0BAAA,EAA6B,WAAW,CAAC,OAAO,CAAA,EAAA,EAAK,WAAW,CAAC,YAAY,CAAyH,uHAAA,CAAA;AACzM,KAAA,CAAC,CACH;AAED,IAAA,OAAO,CAAC,GAAG,gBAAgB,EAAE,GAAG,kBAAkB,CAAC;AACrD;AAEA,SAAS,kBAAkB,CAAC,IAAY,EAAE,UAAkB,EAAA;AAC1D,IAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU;AACzC,UAAE,IAAI,CAAC,SAAS,CAAC,UAAU;UACzB,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC;IAElC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;AAC9C,IAAA,IAAI,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE;QAC1D,MAAM,IAAI,cAAc,CACtB,CAAA,KAAA,EAAQ,UAAU,CAAkC,+BAAA,EAAA,IAAI,CAAE,CAAA,CAC3D;;AAGH,IAAA,OAAO,QAAQ;AACjB;AAEA,eAAe,iBAAiB,CAC9B,IAAY,EACZ,MAAc,EAAA;AAEd,IAAA,IAAI;QACF,MAAM,QAAQ,GAAG,kBAAkB,CAAC,IAAI,EAAE,MAAM,CAAC;QACjD,OAAO,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAwB,CAAC;;IAC1D,OAAO,KAAK,EAAE;AACd,QAAA,IAAI,KAAK,YAAY,cAAc,EAAE;AACnC,YAAA,MAAM,cAAc,CAAC,KAAK,CAAC,OAAO,CAAC;;;AAGrC,QAAA,MAAM,KAAK;;AAEf;AAEA,SAAS,kBAAkB,CAAC,IAAY,EAAA;IACtC,MAAM,UAAU,GAAgB,EAAE;AAElC,IAAA,KAAK,MAAM,SAAS,IAAI,kBAAkB,EAAE;QAC1C,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,SAAS,CAAC;AAC5C,QAAA,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,EAAE;YACtE;;QAGF,KAAK,MAAM,KAAK,IAAI,EAAE,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE;YAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC;YAC5C,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,MAAM,EAAE;gBAAE;YAErC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI;YACnC,MAAM,OAAO,GAAG,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC;AACjD,YAAA,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;YACrD,MAAM,WAAW,GAAG,kBAAkB,CAAC,OAAO,EAAE,QAAQ,CAAC;YAEzD,UAAU,CAAC,IAAI,CAAC;gBACd,IAAI;gBACJ,KAAK;gBACL,WAAW;gBACX,OAAO;AACP,gBAAA,YAAY,EAAE,QAAQ;AACvB,aAAA,CAAC;;;AAIN,IAAA,MAAM,MAAM,GAAG,IAAI,GAAG,EAAqB;AAC3C,IAAA,KAAK,MAAM,MAAM,IAAI,UAAU,EAAE;QAC/B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE;YAC5B,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC;;;AAInC,IAAA,OAAO,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,KAC3C,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,CAC7B;AACH;AAEA,SAAS,YAAY,CAAC,OAAoB,EAAE,aAAqB,EAAA;AAC/D,IAAA,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,KAAK,aAAa,CAAC;AACtE,IAAA,IAAI,MAAM;AAAE,QAAA,OAAO,MAAM;AAEzB,IAAA,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAC3B,CAAC,MAAM,KAAK,MAAM,CAAC,IAAI,KAAK,mBAAmB,CAChD;AACD,IAAA,IAAI,QAAQ;AAAE,QAAA,OAAO,QAAQ;AAE7B,IAAA,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;AACnB,QAAA,MAAM,IAAI,cAAc,CAAC,oCAAoC,CAAC;;AAGhE,IAAA,OAAO,OAAO,CAAC,CAAC,CAAC;AACnB;AAEA,SAAS,yBAAyB,CAAC,EACjC,QAAQ,EACR,WAAW,EACX,MAAM,EACN,aAAa,EACb,WAAW,EACX,eAAe,EACf,iBAAiB,GASlB,EAAA;IACC,MAAM,QAAQ,GAAa,EAAE;IAE7B,IAAI,eAAe,EAAE;QACnB,QAAQ,CAAC,IAAI,CACX,CAAsC,mCAAA,EAAA,MAAM,CAAC,IAAI,CAAa,UAAA,EAAA,QAAQ,CAAE,CAAA,CACzE;;IAGH,IAAI,aAAa,EAAE;AACjB,QAAA,QAAQ,CAAC,IAAI,CACX,CAAuB,oBAAA,EAAA,MAAM,CAAC,KAAK,CAAA,KAAA,EAAQ,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,CAAA,CAAE,CACnE;;AAGH,IAAA,IAAI,iBAAiB,EAAE,IAAI,EAAE,EAAE;QAC7B,QAAQ,CAAC,IAAI,CAAC,CAA4B,yBAAA,EAAA,iBAAiB,CAAC,IAAI,EAAE,CAAE,CAAA,CAAC;;IAGvE,IAAI,WAAW,EAAE;AACf,QAAA,QAAQ,CAAC,IAAI,CACX,CAAA,mBAAA,EAAsB,qBAAqB,CAAC,QAAQ,CAAC,CAAK,EAAA,EAAA,WAAW,CAAU,QAAA,CAAA,CAChF;;IAGH,OAAO;AACL,QAAA,OAAO,EAAE;AACP,YAAA;AACE,gBAAA,IAAI,EAAE,MAAM;AACZ,gBAAA,IAAI,EAAE,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC;AAC5B,aAAA;AACF,SAAA;KACsB;AAC3B;AAEA,SAAS,kBAAkB,CAAC,OAAe,EAAE,QAAgB,EAAA;IAC3D,MAAM,SAAS,GAAG;SACf,KAAK,CAAC,OAAO;SACb,GAAG,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI,EAAE;AACzB,SAAA,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;IAElC,QACE,SAAS,EAAE,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC;QACxB,CAAoC,iCAAA,EAAA,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA,CAAE;AAEjE;AAEA,SAAS,WAAW,CAAC,KAAa,EAAA;AAChC,IAAA,OAAO;SACJ,KAAK,CAAC,KAAK;SACX,MAAM,CAAC,OAAO;SACd,GAAG,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE;SACxE,IAAI,CAAC,GAAG,CAAC;AACd;AAEA,SAAS,qBAAqB,CAAC,QAAgB,EAAA;IAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE;IACtD,QAAQ,SAAS;AACf,QAAA,KAAK,KAAK;AACV,QAAA,KAAK,MAAM;AACT,YAAA,OAAO,IAAI;AACb,QAAA,KAAK,KAAK;AACV,QAAA,KAAK,MAAM;AACT,YAAA,OAAO,IAAI;AACb,QAAA,KAAK,OAAO;AACV,YAAA,OAAO,MAAM;AACf,QAAA,KAAK,KAAK;AACR,YAAA,OAAO,IAAI;AACb,QAAA;AACE,YAAA,OAAO,MAAM;;AAEnB;;ACzhBA;;;;;;AAMG;AACI,MAAM,aAAa,GAAG;;ACP7B;AAKA;;;;;;;;;;;;;AAaG;MACU,QAAQ,CAAA;AACnB;;;;;;AAMG;AACH,IAAA,aAAa,YAAY,CAAC,IAAY,EAAA;AACpC,QAAA,IAAI;YACF,OAAO,QAAQ,CAAC,eAAe,CAAC,OAAO,IAAI,CAAC,CAAC;;QAC7C,OAAO,CAAU,EAAE;YACnB,MAAM,IAAI,KAAK,CACb,CAAA,oBAAA,EAAuB,IAAI,CAAK,EAAA,EAAA,CAAC,YAAY,KAAK,GAAG,CAAC,CAAC,OAAO,GAAG,CAAC,CAAE,CAAA,CACrE;;;AAIL;;;;;;;;AAQG;AACH,IAAA,aAAa,eAAe,CAAI,aAAyB,EAAA;;AAEvD,QAAA,OAAO,aAAa,CAAC,IAAI,CACvB,CAAC,CAAU,MAAO,CAAoB,CAAC,OAAO,IAAI,CAAC,CAAM,CAC1D;;AAGH;;;;;;;AAOG;IACK,OAAO,UAAU,CAAC,QAAgB,EAAA;AACxC,QAAA,IAAI;YACF,OAAO,IAAI,CAAC,KAAK,CACf,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,cAAc,CAAC,EAAE,MAAM,CAAC,CAC7D;;QACD,OAAO,CAAU,EAAE;YACnB,MAAM,IAAI,KAAK,CAAC,CAAA,4BAAA,EAA+B,QAAQ,CAAK,EAAA,EAAA,CAAC,CAAE,CAAA,CAAC;;;AAIpE;;;;;;AAMG;IACH,OAAO,cAAc,CAAC,QAAgB,EAAA;QACpC,OAAO,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAW;;AAG3D;;;;;;AAMG;IACH,OAAO,WAAW,CAAC,QAAgB,EAAA;AACjC,QAAA,MAAM,IAAI,GAAI,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAY,CAAC,KAAK,CAAC,GAAG,CAAC;QACzE,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;;AAE/B;;AC7FD;AASA;;;;;;;;;;;;;;;;AAgBG;AACG,MAAO,UAAW,SAAQ,WAAW,CAAA;AAKzC,IAAA,WAAA,CACU,QAAmB,GAAA,IAAI,EACvB,WAAA,GAAc,CAAC,EAAA;AAEvB,QAAA,KAAK,EAAE;QAHC,IAAQ,CAAA,QAAA,GAAR,QAAQ;QACR,IAAW,CAAA,WAAA,GAAX,WAAW;QALb,IAAO,CAAA,OAAA,GAA2B,EAAE;QAQ1C,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC;;AAG/C;;;;;AAKG;AACH,IAAA,IAAY,GAAG,GAAA;AACb,QAAA,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE;AACd,YAAA,IAAI,CAAC,IAAI,GAAG,IAAI,OAAO,CAAC;AACtB,gBAAA,IAAI,EAAE,qBAAqB;AAC3B,gBAAA,YAAY,EAAE,EAAE;AAChB,gBAAA,OAAO,EAAEH,SAAc;AACxB,aAAA,CAAC;;QAEJ,OAAO,IAAI,CAAC,IAAI;;AAGlB;;;;AAIG;AACK,IAAA,MAAM,IAAI,CAChB,MAAe,EACf,QAAgB,EAAA;AAEhB,QAAA,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;AAEnC,QAAA,IAAI,GAAW,EAAE,OAAe,EAAE,MAAW;AAC7C,QAAA,IAAI;YACF,MAAM,GAAG,GAAG,MAAM,QAAQ,CAAC,YAAY,CAAC,QAAQ,CAAC;AACjD,YAAA,GAAG,GAAG,GAAG,CAAC,YAAY;AACtB,YAAA,OAAO,GAAG,GAAG,CAAC,OAAO;AACrB,YAAA,MAAM,GAAG,GAAG,CAAC,MAAM;;QACnB,OAAO,CAAU,EAAE;YACnB,MAAM,IAAI,KAAK,CAAE,CAAS,CAAC,OAAO,IAAK,CAAS,CAAC;;AAEnD,QAAA,IAAI;YACF,GAAG,CAAC,IAAI,CAAC,CAAA,iCAAA,EAAoC,GAAG,CAAK,EAAA,EAAA,OAAO,CAAE,CAAA,CAAC;AAC/D,YAAA,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;AAC7B,YAAA,MAAM,GAAG,MAAM,YAAY,OAAO,GAAG,MAAM,MAAM,GAAG,MAAM;;QAC1D,OAAO,CAAU,EAAE;YACnB,MAAM,IAAI,KAAK,CACb,CAAoC,iCAAA,EAAA,GAAG,IAAI,SAAS,CAAA,OAAA,EAAU,QAAQ,CAAA,EAAA,EAAK,CAAC,YAAY,KAAK,GAAG,CAAC,CAAC,OAAO,GAAG,CAAC,CAAE,CAAA,CAChH;;QAEH,OAAO;AACL,YAAA,GAAG,EAAE,MAAM;AACX,YAAA,OAAO,EAAE,GAAG;AACZ,YAAA,OAAO,EAAE,OAAO;SACjB;;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BG;AACK,IAAA,MAAM,IAAI,GAAA;AAChB,QAAA,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC;AAEnC,QAAA,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC;AAC3D,QAAA,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC;AACtD,QAAA,IAAI,MAAM,GAAG,IAAI,CAAC,GAAG;AACrB,QAAA,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE;AAC5B,YAAA,IAAI,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC,EAAE;gBACpC;;AAEF,YAAA,IAAI;gBACF,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;AAC3C,gBAAA,MAAM,GAAG,GAAG,CAAC,GAAG;;YAChB,OAAO,CAAU,EAAE;gBACnB,GAAG,CAAC,KAAK,CAAC,CAAA,+BAAA,EAAkC,MAAM,CAAK,EAAA,EAAA,CAAC,CAAE,CAAA,CAAC;;;QAG/D,OAAO,CAAC,GAAG,CACT,CAAoB,iBAAA,EAAA,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO;aACzC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAA,EAAA,EAAK,CAAC,CAAA,CAAE;AACnB,aAAA,IAAI,CAAC,IAAI,CAAC,CAAA,CAAE,CAChB;AACD,QAAA,OAAO,MAAM;;AAGf;;;;;;;;;AASG;AACK,IAAA,KAAK,CAAC,QAAgB,EAAE,MAAA,GAAiB,CAAC,EAAA;QAChD,IAAI,MAAM,IAAI,CAAC;AAAE,YAAA,OAAO,EAAE;AAC1B,QAAA,OAAO,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC,KAAe,EAAE,IAAI,KAAI;YAC/D,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC;YAChC,IAAI,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE;AACnC,gBAAA,KAAK,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC;;AACtC,iBAAA,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,MAAM,CAAC,CAAG,EAAA,aAAa,WAAW,EAAE,IAAI,CAAC,CAAC,EAAE;AACpE,gBAAA,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC;;AAElB,YAAA,OAAO,KAAK;SACb,EAAE,EAAE,CAAC;;AAGR;;;;;;;;;;;;;;;;;;;AAmBG;;AAEH,IAAA,MAAM,GAAG,CAAC,IAAiB,GAAA,OAAO,CAAC,IAAI,EAAA;AACrC,QAAA,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,IAAI,EAAE;QAChC,MAAM,MAAM,CAAC,KAAK,CAAC,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC;;AAEjD;;;;"}
+export { CLIENT_INTEGRATIONS, DEFAULT_PROMPT_NAME, EnrichCore, EnrichCoreWithAggregation, MCP_FILE_NAME, McpUtils, McpWrapper, PACKAGE_NAME, PROMPT_DIRECTORIES, REQUIRED_MODULE_FOLDERS, VERSION, WORKSPACE_ROOT_ENV, __resetWorkspaceRoot, aggregateModules, aggregateModulesSync, buildDecorationResourceTemplates, buildDocPrompts, buildDocumentationPayload, buildPrompts, buildResourceTemplates, decorationResourceTemplates, discoverDocPrompts, enrich, getWorkspaceRoot, listModuleDirectories, promptList, refreshPrompts, resolveModuleFolderPath, resolveModulePath, resolveModulesRoot, resources, selectPrompt, setWorkspaceRoot, templateList, toolList, tools, validateModules, workspaceResourceTemplates };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"mcp-server.esm.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","toolList","tools","modulePackage","decorationModule","mcpModule","templateModule","coreToolList","VERSION","PACKAGE_NAME","PKG","V","path","fs"],"mappings":"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"}