@decaf-ts/mcp-server 0.0.4 → 0.3.0

package/lib/mcp/code.cjs

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSourceFile = isSourceFile;
+exports.isTestFile = isTestFile;
+exports.extractExports = extractExports;
+exports.extractDecorators = extractDecorators;
+exports.summarizeReadme = summarizeReadme;
+exports.analyzeRepo = analyzeRepo;
+// Analysis helpers (minimal yet effective, text-based to avoid heavy AST deps)
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const utils_1 = require("./utils.cjs");
+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_1.default.join(root, "src");
+    const testDir = path_1.default.join(root, "tests");
+    const readmePath = path_1.default.join(root, "README.md");
+    const readme = (0, utils_1.readFileSafe)(readmePath);
+    const files = fs_1.default.existsSync(src) ? (0, utils_1.listFilesRecursive)(src, isSourceFile) : [];
+    const testFiles = fs_1.default.existsSync(testDir)
+        ? (0, utils_1.listFilesRecursive)(testDir, (f) => isSourceFile(f) && isTestFile(f))
+        : [];
+    const api = {};
+    for (const f of files) {
+        const content = (0, utils_1.readFileSafe)(f) || "";
+        api[path_1.default.relative(root, f)] = {
+            exports: extractExports(content),
+            decorators: extractDecorators(content),
+        };
+    }
+    const tests = {};
+    for (const f of testFiles) {
+        const content = (0, utils_1.readFileSafe)(f) || "";
+        const mentions = Array.from(new Set([...extractExports(content), ...extractDecorators(content)])).sort();
+        tests[path_1.default.relative(root, f)] = { mentions };
+    }
+    return { files, testFiles, api, tests, readme: summarizeReadme(readme) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"code.js","sourceRoot":"","sources":["../../src/mcp/code.ts"],"names":[],"mappings":"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","sourcesContent":["// 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"]}

package/lib/mcp/code.d.ts

@@ -0,0 +1,23 @@
+export declare function isSourceFile(p: string): boolean;
+export declare function isTestFile(p: string): boolean;
+export declare function extractExports(fileContent: string): string[];
+export declare function extractDecorators(fileContent: string): string[];
+export declare function summarizeReadme(readme?: string): {
+    title: string;
+    bullets: string[];
+} | undefined;
+export declare function analyzeRepo(root: string): {
+    files: string[];
+    testFiles: string[];
+    api: Record<string, {
+        exports: string[];
+        decorators: string[];
+    }>;
+    tests: Record<string, {
+        mentions: string[];
+    }>;
+    readme: {
+        title: string;
+        bullets: string[];
+    } | undefined;
+};

package/lib/mcp/decorator-tools.cjs

@@ -0,0 +1,243 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoratorTools = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function formatDecorator(spec) {
+    const args = (spec.args || []).map((arg) => JSON.stringify(arg)).join(", ");
+    return `@${spec.name}(${args})`;
+}
+function ensureDirectory(filePath) {
+    fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+}
+function collectDecoratorNames(classDecorators, properties) {
+    const names = new Set();
+    names.add("model");
+    for (const decorator of classDecorators || []) {
+        names.add(decorator.name);
+    }
+    for (const property of properties || []) {
+        for (const decorator of property.decorators || []) {
+            names.add(decorator.name);
+        }
+    }
+    return names;
+}
+function ensureImport(content, importsFrom, decorators) {
+    /* istanbul ignore next */
+    if (!decorators.size)
+        return content;
+    const importRegex = new RegExp(`import\\s+\\{([^}]+)\\}\\s+from\\s+["']${escapeRegExp(importsFrom)}["'];`);
+    const match = content.match(importRegex);
+    const sorted = Array.from(decorators).sort();
+    if (match) {
+        const existing = match[1]
+            .split(",")
+            .map((name) => name.trim())
+            .filter(Boolean);
+        const merged = Array.from(new Set([...existing, ...sorted])).sort();
+        return content.replace(importRegex, `import { ${merged.join(", ")} } from "${importsFrom}";`);
+    }
+    const importLine = `import { ${sorted.join(", ")} } from "${importsFrom}";`;
+    return `${importLine}\n\n${content}`;
+}
+function addPropertyBlock(property) {
+    const decorators = (property.decorators || [])
+        .map(formatDecorator)
+        .join("\n  ");
+    const decoratorBlock = decorators ? `  ${decorators}\n` : "";
+    return `${decoratorBlock}  ${property.name}: ${property.type};`;
+}
+function removePropertyBlock(content, propertyName) {
+    const lines = content.split(/\r?\n/);
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim().startsWith(`@`) &&
+            lines[i + 1]?.includes(`${propertyName}:`)) {
+            continue;
+        }
+        if (line.includes(`${propertyName}:`)) {
+            // skip this line and any trailing blank line
+            continue;
+        }
+        result.push(line);
+    }
+    return result.join("\n");
+}
+function insertDecorator(content, decorator, target) {
+    const decoratorLine = formatDecorator(decorator);
+    if (target.kind === "class") {
+        const classRegex = /(export\s+class\s+[^\s{]+\s*\{)/;
+        if (content.includes(decoratorLine))
+            return content;
+        return content.replace(classRegex, `${decoratorLine}\n$1`);
+    }
+    if (!target.name)
+        return content;
+    const propertyRegex = new RegExp(`(^\\s*)(?:@.*\\n\\1)*${escapeRegExp(target.name)}:`, "m");
+    const match = propertyRegex.exec(content);
+    if (!match)
+        return content;
+    const indent = match[1] || "  ";
+    if (content.includes(`${indent}${decoratorLine}`))
+        return content;
+    return (content.slice(0, match.index) +
+        `${indent}${decoratorLine}\n` +
+        content.slice(match.index));
+}
+function removeDecorator(content, decoratorName, target) {
+    const decoratorRegex = new RegExp(`^\\s*@${escapeRegExp(decoratorName)}\\([^)]*\\)`, "m");
+    if (target.kind === "class") {
+        return content.replace(decoratorRegex, "");
+    }
+    if (target.name) {
+        const pattern = new RegExp(`(^\\s*@${escapeRegExp(decoratorName)}\\([^)]*\\)\\s*$\\n)(?=\\s*${escapeRegExp(target.name)}:)`, "m");
+        return content.replace(pattern, "");
+    }
+    return content;
+}
+function writeIfChanged(filePath, content) {
+    ensureDirectory(filePath);
+    fs_1.default.writeFileSync(filePath, content);
+}
+exports.decoratorTools = {
+    createOrUpdateModelTool: {
+        name: "create-or-update-model",
+        description: "Create or update a validation-ready model class",
+        execute: async (args) => {
+            if (!args.overwrite && fs_1.default.existsSync(args.filePath)) {
+                throw new Error(`File already exists at ${args.filePath}`);
+            }
+            const decorators = collectDecoratorNames(args.classDecorators, args.properties);
+            let content = `@model()`;
+            for (const decorator of args.classDecorators || []) {
+                content += `\n${formatDecorator(decorator)}`;
+            }
+            const properties = (args.properties || [])
+                .map(addPropertyBlock)
+                .join("\n\n");
+            content += `\nexport class ${args.className} {\n${properties ? `${properties}\n` : ""}}\n`;
+            content = ensureImport(content, args.importsFrom, decorators);
+            writeIfChanged(args.filePath, content);
+            return { filePath: args.filePath };
+        },
+    },
+    addAttributeTool: {
+        name: "add-attribute",
+        description: "Add a decorated attribute to an existing model",
+        execute: async (args) => {
+            if (!fs_1.default.existsSync(args.filePath)) {
+                throw new Error(`Model file not found at ${args.filePath}`);
+            }
+            let content = fs_1.default.readFileSync(args.filePath, "utf8");
+            if (content.includes(`${args.attribute.name}:`)) {
+                return { filePath: args.filePath };
+            }
+            const decorators = collectDecoratorNames(undefined, [args.attribute]);
+            content = ensureImport(content, args.importsFrom, decorators);
+            const insertionPoint = content.lastIndexOf("}");
+            const block = addPropertyBlock(args.attribute);
+            const before = content.slice(0, insertionPoint).replace(/\s*$/, "");
+            const after = content.slice(insertionPoint);
+            const updated = `${before}\n${block}\n${after}`;
+            writeIfChanged(args.filePath, updated);
+            return { filePath: args.filePath };
+        },
+    },
+    removeAttributeTool: {
+        name: "remove-attribute",
+        description: "Remove an attribute from a model class",
+        execute: async (args) => {
+            if (!fs_1.default.existsSync(args.filePath))
+                return { filePath: args.filePath };
+            const content = fs_1.default.readFileSync(args.filePath, "utf8");
+            const updated = removePropertyBlock(content, args.attributeName);
+            writeIfChanged(args.filePath, updated);
+            return { filePath: args.filePath };
+        },
+    },
+    applyDecoratorTool: {
+        name: "apply-decorator",
+        description: "Apply a decorator to a class or property",
+        execute: async (args) => {
+            if (!fs_1.default.existsSync(args.filePath)) {
+                throw new Error(`Model file not found at ${args.filePath}`);
+            }
+            let content = fs_1.default.readFileSync(args.filePath, "utf8");
+            const decorators = new Set([args.decorator.name]);
+            content = ensureImport(content, args.importsFrom, decorators);
+            content = insertDecorator(content, args.decorator, args.target);
+            writeIfChanged(args.filePath, content);
+            return { filePath: args.filePath };
+        },
+    },
+    removeDecoratorTool: {
+        name: "remove-decorator",
+        description: "Remove a decorator from a class or property",
+        execute: async (args) => {
+            if (!fs_1.default.existsSync(args.filePath))
+                return { filePath: args.filePath };
+            let content = fs_1.default.readFileSync(args.filePath, "utf8");
+            content = removeDecorator(content, args.decoratorName, args.target);
+            writeIfChanged(args.filePath, content);
+            return { filePath: args.filePath };
+        },
+    },
+    scaffoldValidatorTool: {
+        name: "scaffold-validator",
+        description: "Scaffold a validator class and optional decorator",
+        execute: async (args) => {
+            const classFile = path_1.default.join(args.validatorsDir, `${args.name}.ts`);
+            ensureDirectory(classFile);
+            const classContent = `export class ${args.name} {\n  validate(value: unknown): boolean {\n    return value !== undefined;\n  }\n}\n`;
+            fs_1.default.writeFileSync(classFile, classContent);
+            let decoratorFile;
+            if (args.decoratorDir) {
+                decoratorFile = path_1.default.join(args.decoratorDir, `${args.name}Decorator.ts`);
+                ensureDirectory(decoratorFile);
+                fs_1.default.writeFileSync(decoratorFile, `export function ${args.name}Decorator() {\n  return () => void 0;\n}\n`);
+            }
+            return { classFile, decoratorFile };
+        },
+    },
+    scaffoldSerializerTool: {
+        name: "scaffold-serializer",
+        description: "Scaffold a serializer class and optional registry",
+        execute: async (args) => {
+            const classFile = path_1.default.join(args.dir, `${args.name}.ts`);
+            ensureDirectory(classFile);
+            fs_1.default.writeFileSync(classFile, `export class ${args.name} {\n  serialize(value: unknown): string {\n    return JSON.stringify(value);\n  }\n}\n`);
+            let registerFile;
+            if (args.registerDir) {
+                registerFile = path_1.default.join(args.registerDir, `${args.name}Register.ts`);
+                ensureDirectory(registerFile);
+                fs_1.default.writeFileSync(registerFile, `export function register${args.name}() {\n  return ${args.setDefault ? "'default'" : "'optional'"};\n}\n`);
+            }
+            return { classFile, registerFile };
+        },
+    },
+    scaffoldHashingTool: {
+        name: "scaffold-hashing",
+        description: "Scaffold a hashing function and optional registry",
+        execute: async (args) => {
+            const functionFile = path_1.default.join(args.dir, `${args.name}.ts`);
+            ensureDirectory(functionFile);
+            fs_1.default.writeFileSync(functionFile, `export function ${args.name}(value: string): string {\n  return value.split('').reverse().join('');\n}\n`);
+            let registerFile;
+            if (args.registerDir) {
+                registerFile = path_1.default.join(args.registerDir, `${args.name}Register.ts`);
+                ensureDirectory(registerFile);
+                fs_1.default.writeFileSync(registerFile, `export function register${args.name}() {\n  return ${args.setDefault ? "'default'" : "'optional'"};\n}\n`);
+            }
+            return { functionFile, registerFile };
+        },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorator-tools.js","sourceRoot":"","sources":["../../src/mcp/decorator-tools.ts"],"names":[],"mappings":"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","sourcesContent":["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"]}

package/lib/mcp/fastmcp-wiring.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnrichCoreWithAggregation = EnrichCoreWithAggregation;
+const aggregateModules_1 = require("./aggregateModules.cjs");
+const prompts_1 = require("./prompts/index.cjs");
+const tools_1 = require("./tools/index.cjs");
+const resources_1 = require("./resources/index.cjs");
+const templates_1 = require("./templates/index.cjs");
+/**
+ * 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 {
+        (0, prompts_1.loadPrompts)();
+        for (const prompt of prompts_1.promptList)
+            server.addPrompt(prompt);
+    }
+    catch (e) {
+        // ignore if loadPrompts not available or fails
+    }
+    try {
+        for (const tool of tools_1.toolList)
+            server.addTool(tool);
+    }
+    catch (e) { }
+    try {
+        for (const resource of resources_1.resources)
+            server.addResource(resource);
+    }
+    catch (e) { }
+    try {
+        const templates = (0, templates_1.buildResourceTemplates)();
+        for (const template of templates)
+            server.addResourceTemplate(template);
+    }
+    catch (e) { }
+    // Now aggregate modules and register aggregated assets with provenance
+    const agg = await (0, aggregateModules_1.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,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp/fastmcp-wiring.d.ts

@@ -0,0 +1,14 @@
+export type FastMCPLike = {
+    addPrompt: (p: any) => void;
+    addTool: (t: any) => void;
+    addResource: (r: any) => void;
+    addResourceTemplate: (t: any) => void;
+};
+/**
+ * Aggregate module assets and register them on the provided FastMCP-like server.
+ * Falls back to built-in lists if aggregation yields none.
+ */
+export declare function EnrichCoreWithAggregation(server: FastMCPLike, repoRoot?: string): Promise<{
+    modulesChecked: number;
+    conflicts: import("./aggregateModules").AggregationConflict[];
+}>;

package/lib/mcp/index.cjs

@@ -1,17 +1,52 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = exports.PACKAGE_NAME = exports.buildDocPrompts = exports.buildResourceTemplates = exports.getWorkspaceRoot = exports.setWorkspaceRoot = exports.tools = exports.enrich = exports.default = void 0;
-var mcp_1 = require("./../modules/mcp/index.cjs");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(mcp_1).default; } });
-Object.defineProperty(exports, "enrich", { enumerable: true, get: function () { return mcp_1.enrich; } });
-Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return mcp_1.tools; } });
-Object.defineProperty(exports, "setWorkspaceRoot", { enumerable: true, get: function () { return mcp_1.setWorkspaceRoot; } });
-Object.defineProperty(exports, "getWorkspaceRoot", { enumerable: true, get: function () { return mcp_1.getWorkspaceRoot; } });
-Object.defineProperty(exports, "buildResourceTemplates", { enumerable: true, get: function () { return mcp_1.buildResourceTemplates; } });
-Object.defineProperty(exports, "buildDocPrompts", { enumerable: true, get: function () { return mcp_1.buildDocPrompts; } });
-Object.defineProperty(exports, "PACKAGE_NAME", { enumerable: true, get: function () { return mcp_1.PACKAGE_NAME; } });
-Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return mcp_1.VERSION; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvbWNwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7OztBQUFBLGtEQUE0SjtBQUFuSiwrR0FBQSxPQUFPLE9BQUE7QUFBRSw2RkFBQSxNQUFNLE9BQUE7QUFBRSw0RkFBQSxLQUFLLE9BQUE7QUFBRSx1R0FBQSxnQkFBZ0IsT0FBQTtBQUFFLHVHQUFBLGdCQUFnQixPQUFBO0FBQUUsNkdBQUEsc0JBQXNCLE9BQUE7QUFBRSxzR0FBQSxlQUFlLE9BQUE7QUFBRSxtR0FBQSxZQUFZLE9BQUE7QUFBRSw4RkFBQSxPQUFPLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBkZWZhdWx0LCBlbnJpY2gsIHRvb2xzLCBzZXRXb3Jrc3BhY2VSb290LCBnZXRXb3Jrc3BhY2VSb290LCBidWlsZFJlc291cmNlVGVtcGxhdGVzLCBidWlsZERvY1Byb21wdHMsIFBBQ0tBR0VfTkFNRSwgVkVSU0lPTiB9IGZyb20gXCIuLi9tb2R1bGVzL21jcFwiO1xuIl19
+exports.EnrichCoreWithAggregation = exports.aggregateModulesSync = exports.aggregateModules = exports.validateModules = exports.default = void 0;
+exports.EnrichCore = EnrichCore;
+const prompts_1 = require("./prompts/index.cjs");
+const tools_1 = require("./tools/index.cjs");
+const resources_1 = require("./resources/index.cjs");
+const templates_1 = require("./templates/index.cjs");
+__exportStar(require("./mcp-module.cjs"), exports);
+var mcp_module_1 = require("./mcp-module.cjs");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(mcp_module_1).default; } });
+var validation_1 = require("./validation/index.cjs");
+Object.defineProperty(exports, "validateModules", { enumerable: true, get: function () { return validation_1.validateModules; } });
+var aggregateModules_1 = require("./aggregateModules.cjs");
+Object.defineProperty(exports, "aggregateModules", { enumerable: true, get: function () { return aggregateModules_1.aggregateModules; } });
+Object.defineProperty(exports, "aggregateModulesSync", { enumerable: true, get: function () { return aggregateModules_1.aggregateModulesSync; } });
+var fastmcp_wiring_1 = require("./fastmcp-wiring.cjs");
+Object.defineProperty(exports, "EnrichCoreWithAggregation", { enumerable: true, get: function () { return fastmcp_wiring_1.EnrichCoreWithAggregation; } });
+function EnrichCore(server) {
+    (0, prompts_1.loadPrompts)();
+    for (const prompt of prompts_1.promptList) {
+        server.addPrompt(prompt);
+    }
+    for (const tool of tools_1.toolList) {
+        server.addTool(tool);
+    }
+    for (const resource of resources_1.resources) {
+        server.addResource(resource);
+    }
+    const templates = (0, templates_1.buildResourceTemplates)();
+    for (const template of templates) {
+        server.addResourceTemplate(template);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp/index.d.ts

@@ -1 +1,7 @@
-export { default, enrich, tools, setWorkspaceRoot, getWorkspaceRoot, buildResourceTemplates, buildDocPrompts, PACKAGE_NAME, VERSION } from "../modules/mcp";
+import { FastMCP } from "fastmcp";
+export * from "./mcp-module";
+export { default } from "./mcp-module";
+export { validateModules } from "./validation";
+export { aggregateModules, aggregateModulesSync } from "./aggregateModules";
+export { EnrichCoreWithAggregation } from "./fastmcp-wiring";
+export declare function EnrichCore(server: FastMCP): void;