@decaf-ts/mcp-server 0.0.3 → 0.0.4

package/lib/esm/metadata.js

@@ -6,7 +6,7 @@ import { Metadata } from "@decaf-ts/decoration";
  * @summary The actual version number is replaced during the build process.
  * @type {string}
  */
-export const VERSION = "0.0.2";
+export const VERSION = "0.0.3";
 export const PACKAGE_NAME = "##PACKAGE_NAME##";
 try {
     Metadata.registerLibrary(PACKAGE_NAME, VERSION);

package/lib/esm/modules/{decoration-assist/index.d.ts → mcp/decoration-assist.d.ts}

@@ -34,6 +34,6 @@ export type AnalyzeRepoArgs = z.infer<typeof analyzeRepoSchema>;
 export type EnumerateCapabilitiesArgs = z.infer<typeof enumerateCapabilitiesSchema>;
 export type PlanFeatureArgs = z.infer<typeof planFeatureSchema>;
 export default function enrich(mcp: FastMCP): FastMCP<Record<string, unknown> | undefined>;
-export declare const VERSION = "0.0.2";
+export declare const VERSION = "0.0.3";
 export declare const PACKAGE_NAME = "##PACKAGE_NAME##/decoration-assist";
 export {};

package/lib/esm/modules/mcp/decoration-assist.js

@@ -0,0 +1,353 @@
+import fs from "fs";
+import path from "path";
+import { z } from "zod";
+import { VERSION as V, PACKAGE_NAME as PKG } from "../../metadata";
+// Utility: safe read file
+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();
+}
+// Zod Schemas (with explicit descriptions)
+const analyzeRepoSchema = z
+    .object({
+    repoPath: z
+        .string({
+        description: "Relative or absolute path to the target repository inside this monorepo, e.g. './decoration'.",
+    })
+        .min(1, "repoPath is required"),
+    includeTests: z
+        .boolean({
+        description: "If true, analyze the tests directory (if present) to derive expected behaviors.",
+    })
+        .default(true),
+    includeDocs: z
+        .boolean({
+        description: "If true, analyze README.md and docs directories to extract documented features.",
+    })
+        .default(true),
+})
+    .strict()
+    .describe("Analyze a local repository (e.g. ./decoration) to extract APIs, features, tests, and documentation cues.");
+const enumerateCapabilitiesSchema = z
+    .object({
+    repoPath: z
+        .string({
+        description: "Relative or absolute path to the target repository to enumerate developer-facing capabilities.",
+    })
+        .min(1, "repoPath is required"),
+})
+    .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({
+        description: "Natural-language description of a developer's requested feature or task to implement using the repository and available MCP tools.",
+    })
+        .min(5, "feature must describe the goal clearly"),
+    repoPath: z
+        .string({
+        description: "Target repository path providing the library to use, e.g. './decoration'.",
+    })
+        .default("./decoration"),
+})
+    .strict()
+    .describe("Plan which MCP tools to use and in what sequence to implement a requested feature using the repository.");
+// 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) };
+}
+// Tools
+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 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();
+}
+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),
+                    },
+                ],
+            };
+        },
+    };
+}
+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 buildResourceTemplates(repoPath) {
+    const root = path.resolve(process.cwd(), repoPath);
+    return [
+        {
+            name: "decoration-src",
+            description: "Read a file from the decoration/src tree by relative path.",
+            mimeType: "text/plain",
+            uriTemplate: "decoration://src/{path}",
+            arguments: [
+                {
+                    name: "path",
+                    description: "Path under decoration/src to load, e.g. 'decoration/types.ts'",
+                    required: true,
+                },
+            ],
+            load: async ({ path: rel }) => {
+                const abs = path.join(root, "src", rel);
+                const text = readFileSafe(abs) ?? "";
+                return { text };
+            },
+        },
+    ];
+}
+export default function enrich(mcp) {
+    // Register tools
+    mcp.addTool(buildAnalyzeRepositoryTool());
+    mcp.addTool(buildEnumerateCapabilitiesTool());
+    mcp.addTool(buildPlanFeatureTool());
+    // Prompts/resources
+    const repoPath = "./decoration";
+    for (const p of buildPrompts(repoPath))
+        mcp.addPrompt(p);
+    for (const r of buildResourceTemplates(repoPath))
+        mcp.addResourceTemplate(r);
+    return mcp;
+}
+export const VERSION = V;
+export const PACKAGE_NAME = `${PKG}/decoration-assist`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decoration-assist.js","sourceRoot":"","sources":["../../../../src/modules/mcp/decoration-assist.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\nimport { z } from \"zod\";\nimport type { FastMCP, Tool, InputPrompt } from \"fastmcp\";\nimport { VERSION as V, PACKAGE_NAME as PKG } from \"../../metadata\";\n\n// Utility: safe read file\nfunction 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\nfunction 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\n// Zod Schemas (with explicit descriptions)\nconst analyzeRepoSchema = z\n  .object({\n    repoPath: z\n      .string({\n        description:\n          \"Relative or absolute path to the target repository inside this monorepo, e.g. './decoration'.\",\n      })\n      .min(1, \"repoPath is required\"),\n    includeTests: z\n      .boolean({\n        description:\n          \"If true, analyze the tests directory (if present) to derive expected behaviors.\",\n      })\n      .default(true),\n    includeDocs: z\n      .boolean({\n        description:\n          \"If true, analyze README.md and docs directories to extract documented features.\",\n      })\n      .default(true),\n  })\n  .strict()\n  .describe(\n    \"Analyze a local repository (e.g. ./decoration) to extract APIs, features, tests, and documentation cues.\"\n  );\n\nconst enumerateCapabilitiesSchema = z\n  .object({\n    repoPath: z\n      .string({\n        description:\n          \"Relative or absolute path to the target repository to enumerate developer-facing capabilities.\",\n      })\n      .min(1, \"repoPath is required\"),\n  })\n  .strict()\n  .describe(\n    \"Enumerate the complete set of capabilities a developer is expected to use from the given repository.\"\n  );\n\nconst planFeatureSchema = z\n  .object({\n    feature: z\n      .string({\n        description:\n          \"Natural-language description of a developer's requested feature or task to implement using the repository and available MCP tools.\",\n      })\n      .min(5, \"feature must describe the goal clearly\"),\n    repoPath: z\n      .string({\n        description:\n          \"Target repository path providing the library to use, e.g. './decoration'.\",\n      })\n      .default(\"./decoration\"),\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\n// Types\nexport type AnalyzeRepoArgs = z.infer<typeof analyzeRepoSchema>;\nexport type EnumerateCapabilitiesArgs = z.infer<\n  typeof enumerateCapabilitiesSchema\n>;\nexport type PlanFeatureArgs = z.infer<typeof planFeatureSchema>;\n\n// Analysis helpers (minimal yet effective, text-based to avoid heavy AST deps)\nfunction isSourceFile(p: string) {\n  return /\\.(ts|tsx|js|jsx)$/.test(p) && !p.endsWith(\".d.ts\");\n}\nfunction isTestFile(p: string) {\n  return /(\\.test\\.|\\.spec\\.)/.test(p);\n}\n\nfunction 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\nfunction 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\nfunction 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\nfunction 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\n// Tools\nfunction 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\nfunction 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\nfunction 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\nfunction buildPlanFeatureTool(): Tool<undefined, typeof planFeatureSchema> {\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\nfunction 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\ntype DecorationResourceTemplate = {\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};\nfunction buildResourceTemplates(\n  repoPath: string\n): DecorationResourceTemplate[] {\n  const root = path.resolve(process.cwd(), repoPath);\n  return [\n    {\n      name: \"decoration-src\",\n      description: \"Read a file from the decoration/src tree by relative path.\",\n      mimeType: \"text/plain\",\n      uriTemplate: \"decoration://src/{path}\",\n      arguments: [\n        {\n          name: \"path\",\n          description:\n            \"Path under decoration/src to load, e.g. 'decoration/types.ts'\",\n          required: true,\n        },\n      ],\n      load: async ({ path: rel }: { path: string }) => {\n        const abs = path.join(root, \"src\", rel);\n        const text = readFileSafe(abs) ?? \"\";\n        return { text };\n      },\n    },\n  ];\n}\n\nexport default function enrich(mcp: FastMCP) {\n  // Register tools\n  mcp.addTool(buildAnalyzeRepositoryTool() as any);\n  mcp.addTool(buildEnumerateCapabilitiesTool() as any);\n  mcp.addTool(buildPlanFeatureTool() as any);\n  // Prompts/resources\n  const repoPath = \"./decoration\";\n  for (const p of buildPrompts(repoPath)) mcp.addPrompt(p as any);\n  for (const r of buildResourceTemplates(repoPath))\n    mcp.addResourceTemplate(r as any);\n  return mcp;\n}\n\nexport const VERSION = V;\nexport const PACKAGE_NAME = `${PKG}/decoration-assist`;\n"]}

package/lib/esm/modules/mcp/mcp-module.d.ts

@@ -221,7 +221,7 @@ export declare const tools: {
 export declare function enrich(mcp: FastMCP): FastMCP;
 export default enrich;
 export declare const PACKAGE_NAME = "##PACKAGE_NAME##";
-export declare const VERSION = "0.0.2";
+export declare const VERSION = "0.0.3";
 export declare function setWorkspaceRoot(root: string): void;
 export declare function getWorkspaceRoot(): string;
 export declare function buildResourceTemplates(): WorkspaceResourceTemplate[];

package/lib/metadata.cjs

@@ -9,7 +9,7 @@ const decoration_1 = require("@decaf-ts/decoration");
  * @summary The actual version number is replaced during the build process.
  * @type {string}
  */
-exports.VERSION = "0.0.2";
+exports.VERSION = "0.0.3";
 exports.PACKAGE_NAME = "##PACKAGE_NAME##";
 try {
     decoration_1.Metadata.registerLibrary(exports.PACKAGE_NAME, exports.VERSION);

package/lib/metadata.d.ts

@@ -5,5 +5,5 @@
  * @summary The actual version number is replaced during the build process.
  * @type {string}
  */
-export declare const VERSION = "0.0.2";
+export declare const VERSION = "0.0.3";
 export declare const PACKAGE_NAME = "##PACKAGE_NAME##";