@decaf-ts/mcp-server 0.0.4 → 0.2.0

package/lib/esm/mcp/tools/tools.js

@@ -0,0 +1,273 @@
+import fs from "fs";
+import path from "path";
+import { applyPatch, createTwoFilesPatch } from "diff";
+import { analyzeRepoSchema, codeChangeSchema, documentCodeSchema, enumerateCapabilitiesSchema, planFeatureSchema, } from "../schemas";
+import { analyzeRepo } from "../code";
+import { deriveCapabilities } from "../utils";
+import { getWorkspaceRoot, resolveInWorkspace, throwUserError, WorkspaceError, } from "../workspace";
+import { buildDocumentationPayload, DEFAULT_PROMPT_NAME, discoverDocPrompts, selectPrompt, } from "../prompts/prompts";
+export 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) }],
+            };
+        },
+    };
+}
+export 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),
+                    },
+                ],
+            };
+        },
+    };
+}
+export 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),
+                    },
+                ],
+            };
+        },
+    };
+}
+export 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,
+};
+export 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(),
+];
+export const toolList = [
+    ...analyticTools,
+    documentCodeTool,
+    applyCodeChangeTool,
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../../../src/mcp/tools/tools.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}

package/lib/esm/mcp/types.d.ts

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { analyzeRepoSchema, enumerateCapabilitiesSchema, planFeatureSchema, documentCodeSchema, codeChangeSchema, documentObjectSchema, coverageTaskSchema, readmeImprovementSchema } from "./schemas";
+export type AnalyzeRepoArgs = z.infer<typeof analyzeRepoSchema>;
+export type EnumerateCapabilitiesArgs = z.infer<typeof enumerateCapabilitiesSchema>;
+export type PlanFeatureArgs = z.infer<typeof planFeatureSchema>;
+export type DecorationResourceTemplate = {
+    name: string;
+    description: string;
+    uriTemplate: string;
+    mimeType: string;
+    arguments: ReadonlyArray<{
+        name: string;
+        description: string;
+        required: boolean;
+    }>;
+    load: (args: {
+        path: string;
+    }) => Promise<{
+        text: string;
+    }>;
+};
+export type DocumentCodeArgs = z.infer<typeof documentCodeSchema>;
+export type ApplyCodeChangeArgs = z.infer<typeof codeChangeSchema>;
+export type DocumentObjectArgs = z.infer<typeof documentObjectSchema>;
+export type CoverageTaskArgs = z.infer<typeof coverageTaskSchema>;
+export type ReadmeImprovementArgs = z.infer<typeof readmeImprovementSchema>;
+export type DocPrompt = {
+    name: string;
+    title: string;
+    description: string;
+    content: string;
+    absolutePath: string;
+};
+export type WorkspaceResourceTemplate = {
+    name: string;
+    description: string;
+    uriTemplate: string;
+    mimeType: string;
+    arguments: ReadonlyArray<{
+        name: string;
+        description: string;
+        required: boolean;
+    }>;
+    load: (args: {
+        path: string;
+    }) => Promise<{
+        text: string;
+    }>;
+};
+export type PromptResourceTemplate = {
+    name: string;
+    description: string;
+    uriTemplate: string;
+    mimeType: string;
+    arguments: ReadonlyArray<{
+        name: string;
+        description: string;
+        required: boolean;
+    }>;
+    load: (args: {
+        name: string;
+    }) => Promise<{
+        text: string;
+        uri?: string;
+    }>;
+};

package/lib/esm/mcp/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/mcp/utils.d.ts

@@ -0,0 +1,4 @@
+import { analyzeRepo } from "./code";
+export declare function readFileSafe(filePath: string, encoding?: BufferEncoding): string | undefined;
+export declare function listFilesRecursive(root: string, matcher?: (p: string) => boolean): string[];
+export declare function deriveCapabilities(analysis: ReturnType<typeof analyzeRepo>): string[];

package/lib/esm/mcp/utils.js

@@ -0,0 +1,46 @@
+import fs from "fs";
+import path from "path";
+export function readFileSafe(filePath, encoding = "utf8") {
+    try {
+        return fs.readFileSync(filePath, { encoding });
+    }
+    catch {
+        return undefined;
+    }
+}
+export 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();
+}
+export 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();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/mcp/validation/index.d.ts

@@ -0,0 +1,13 @@
+export type ValidationIssue = {
+    module: string;
+    path: string;
+    type: "missing-folder" | "missing-export" | "empty-list" | "disabled" | "other";
+    detail?: string;
+};
+export type ValidationReport = {
+    ok: boolean;
+    modulesChecked: number;
+    issues: ValidationIssue[];
+};
+export declare function findModuleDirs(repoRoot: string): string[];
+export declare function validateModules(repoRoot: string): ValidationReport;

package/lib/esm/mcp/validation/index.js

@@ -0,0 +1,116 @@
+// New: validation entrypoint for module structure
+import fs from "fs";
+import path from "path";
+const REQUIRED_SUBFOLDERS = ["prompts", "resources", "templates", "tools"];
+export 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 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;
+}
+export 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;
+            }
+            // 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}`,
+                });
+            }
+        }
+    }
+    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 undefined;
+}
+// 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);
+    }
+    console.log("Module validation passed");
+    process.exit(0);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/mcp/validation/index.ts"],"names":[],"mappings":"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","sourcesContent":["// 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"]}

package/lib/esm/mcp/validation/scaffoldModule.d.ts

@@ -0,0 +1,9 @@
+export type ScaffoldResult = {
+    modulePath: string;
+    createdFiles: string[];
+};
+/**
+ * Create a module scaffold under repoRoot/src/modules/<moduleName>
+ * Returns created files list.
+ */
+export declare function scaffoldModule(repoRoot: string, moduleName: string): ScaffoldResult;