@decaf-ts/mcp-server 0.0.3 → 0.2.0

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

@@ -0,0 +1,244 @@
+import fs from "fs";
+import path from "path";
+import { spawnSync } from "child_process";
+import { documentObjectSchema, coverageTaskSchema, readmeImprovementSchema, } from "../schemas";
+import { getWorkspaceRoot, resolveInWorkspace, throwUserError, WorkspaceError, } from "../workspace";
+import { discoverDocPrompts, getObjectPromptDependencies, } from "../prompts/prompts";
+import { listFilesRecursive, readFileSafe } from "../utils";
+import { analyzeRepo, isSourceFile, isTestFile } from "../code";
+function relativeFiles(root, files) {
+    return files.map((file) => path.relative(root, file)).sort();
+}
+function collectPromptSections(names) {
+    const root = getWorkspaceRoot();
+    const promptIndex = new Map(discoverDocPrompts(root).map((prompt) => [prompt.name, prompt]));
+    return names
+        .map((name) => promptIndex.get(name))
+        .filter((prompt) => Boolean(prompt))
+        .map((prompt) => ({
+        name: prompt.name,
+        title: prompt.title,
+        description: prompt.description,
+        content: prompt.content,
+        absolutePath: prompt.absolutePath,
+    }));
+}
+function parseTaskLines(content) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^task\s+\d+/i.test(line));
+}
+function computeCoverageFromFinal(coveragePath) {
+    const payload = JSON.parse(fs.readFileSync(coveragePath, "utf8"));
+    const totals = {
+        statements: { covered: 0, total: 0 },
+        functions: { covered: 0, total: 0 },
+        branches: { covered: 0, total: 0 },
+    };
+    const files = Object.entries(payload).map(([filePath, info]) => {
+        const statementCounts = Object.values(info.s);
+        const functionCounts = Object.values(info.f);
+        const branchCounts = Object.values(info.b).flatMap((value) => Array.isArray(value) ? value : [value]);
+        const statementTotal = statementCounts.length;
+        const functionTotal = functionCounts.length;
+        const branchTotal = branchCounts.length;
+        const statementCovered = statementCounts.filter((count) => count > 0).length;
+        const functionCovered = functionCounts.filter((count) => count > 0).length;
+        const branchCovered = branchCounts.filter((count) => count > 0).length;
+        totals.statements.covered += statementCovered;
+        totals.statements.total += statementTotal;
+        totals.functions.covered += functionCovered;
+        totals.functions.total += functionTotal;
+        totals.branches.covered += branchCovered;
+        totals.branches.total += branchTotal;
+        const pct = (covered, total) => total === 0 ? 100 : Number(((covered / total) * 100).toFixed(2));
+        return {
+            path: filePath,
+            statements: pct(statementCovered, statementTotal),
+            functions: pct(functionCovered, functionTotal),
+            branches: pct(branchCovered, branchTotal),
+        };
+    });
+    const pct = (covered, total) => total === 0 ? 100 : Number(((covered / total) * 100).toFixed(2));
+    return {
+        totals: {
+            statements: {
+                ...totals.statements,
+                pct: pct(totals.statements.covered, totals.statements.total),
+            },
+            functions: {
+                ...totals.functions,
+                pct: pct(totals.functions.covered, totals.functions.total),
+            },
+            branches: {
+                ...totals.branches,
+                pct: pct(totals.branches.covered, totals.branches.total),
+            },
+        },
+        files,
+    };
+}
+function normalizePromptSections(sections) {
+    return sections.map((section) => ({
+        name: section.name,
+        title: section.title,
+        tasks: parseTaskLines(section.content),
+        content: section.content,
+    }));
+}
+async function resolveRepoRoot(basePath) {
+    const root = getWorkspaceRoot();
+    try {
+        return resolveInWorkspace(root, basePath);
+    }
+    catch (error) {
+        if (error instanceof WorkspaceError) {
+            await throwUserError(error.message);
+        }
+        throw error;
+    }
+}
+export const documentObjectTool = {
+    name: "document-object",
+    description: "Create a documentation plan for a specific object type using .codex prompts and repository analysis.",
+    parameters: documentObjectSchema,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute: async (input, _context) => {
+        const args = documentObjectSchema.parse(input);
+        const repoRoot = await resolveRepoRoot(args.basePath);
+        const dependencies = getObjectPromptDependencies()[args.objectType] ?? [];
+        if (!dependencies.length) {
+            await throwUserError(`No prompt guidance configured for object type ${args.objectType}`);
+        }
+        const sections = normalizePromptSections(collectPromptSections(dependencies));
+        const srcDir = path.join(repoRoot, "src");
+        const testDir = path.join(repoRoot, "tests");
+        const sourceFiles = fs.existsSync(srcDir)
+            ? listFilesRecursive(srcDir, isSourceFile)
+            : [];
+        const testFiles = fs.existsSync(testDir)
+            ? listFilesRecursive(testDir, (file) => isSourceFile(file) && isTestFile(file))
+            : [];
+        let targetFileContent;
+        if (args.targetFile) {
+            try {
+                const absolute = resolveInWorkspace(repoRoot, args.targetFile);
+                targetFileContent = readFileSafe(absolute) ?? undefined;
+            }
+            catch (error) {
+                if (error instanceof WorkspaceError) {
+                    await throwUserError(error.message);
+                }
+                throw error;
+            }
+        }
+        const payload = {
+            basePath: path.relative(getWorkspaceRoot(), repoRoot) || ".",
+            objectType: args.objectType,
+            targetFile: args.targetFile,
+            guidance: sections,
+            files: {
+                source: relativeFiles(repoRoot, sourceFiles),
+                tests: relativeFiles(repoRoot, testFiles),
+            },
+            targetFileContent: args.includeContent ? targetFileContent : undefined,
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(payload, null, 2),
+                },
+            ],
+        };
+    },
+};
+export const coverageEnforcerTool = {
+    name: "ensure-test-coverage",
+    description: "Run the configured coverage command and report whether the target percentage is met, highlighting weak files.",
+    parameters: coverageTaskSchema,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute: async (input, _context) => {
+        const args = coverageTaskSchema.parse(input);
+        const repoRoot = await resolveRepoRoot(args.basePath);
+        if (!args.dryRun) {
+            const env = {
+                ...process.env,
+                USE_WATCHMAN: "false",
+                WATCHMAN_DISABLE: "1",
+                JEST_DISABLE_WATCHMAN: "1",
+            };
+            const result = spawnSync("npm", ["run", "coverage", "--", "--watchman=false", "--runInBand"], { cwd: repoRoot, env, encoding: "utf8" });
+            if (result.status !== 0) {
+                const message = result.stderr || result.stdout || "Coverage command failed";
+                await throwUserError(message.trim());
+            }
+        }
+        const coveragePath = path.join(repoRoot, "workdocs", "reports", "coverage", "coverage-final.json");
+        if (!fs.existsSync(coveragePath)) {
+            await throwUserError(`Coverage report not found at ${path.relative(repoRoot, coveragePath)}`);
+        }
+        const summary = computeCoverageFromFinal(coveragePath);
+        const meetsThreshold = summary.totals.statements.pct >= args.coverage &&
+            summary.totals.functions.pct >= args.coverage &&
+            summary.totals.branches.pct >= args.coverage;
+        const weakest = [...summary.files]
+            .sort((a, b) => a.statements - b.statements)
+            .slice(0, 10);
+        const guidance = normalizePromptSections(collectPromptSections(["bulk-tests"]));
+        const payload = {
+            basePath: path.relative(getWorkspaceRoot(), repoRoot) || ".",
+            target: args.coverage,
+            meetsThreshold,
+            totals: summary.totals,
+            weakest,
+            guidance,
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(payload, null, 2),
+                },
+            ],
+        };
+    },
+};
+export const readmeImprovementTool = {
+    name: "improve-readme",
+    description: "Summarize required steps to refresh README and workdocs content using .codex guidance and repository analysis.",
+    parameters: readmeImprovementSchema,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute: async (input, _context) => {
+        const args = readmeImprovementSchema.parse(input);
+        const repoRoot = await resolveRepoRoot(args.basePath);
+        const analysis = analyzeRepo(repoRoot);
+        const modules = analysis.files
+            .filter((file) => /index\.ts$/.test(file))
+            .map((file) => path.relative(repoRoot, file));
+        const promptSections = normalizePromptSections(collectPromptSections(["update-readme", "doc", "module"]));
+        const testExamples = Object.keys(analysis.tests ?? {});
+        const examples = args.includeExamples ? testExamples.slice(0, 20) : [];
+        const payload = {
+            basePath: path.relative(getWorkspaceRoot(), repoRoot) || ".",
+            summary: {
+                modules,
+                totalSourceFiles: analysis.files.length,
+                totalTestFiles: analysis.testFiles.length,
+                hasReadme: Boolean(analysis.readme),
+            },
+            guidance: promptSections,
+            suggestedExamples: examples,
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(payload, null, 2),
+                },
+            ],
+        };
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codex-tools.js","sourceRoot":"","sources":["../../../../src/mcp/tools/codex-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\nimport { spawnSync } from \"child_process\";\nimport type { ContentResult, Tool } from \"fastmcp\";\nimport {\n  documentObjectSchema,\n  coverageTaskSchema,\n  readmeImprovementSchema,\n} from \"../schemas\";\nimport {\n  DocumentObjectArgs,\n  CoverageTaskArgs,\n  ReadmeImprovementArgs,\n} from \"../types\";\nimport {\n  getWorkspaceRoot,\n  resolveInWorkspace,\n  throwUserError,\n  WorkspaceError,\n} from \"../workspace\";\nimport {\n  buildObjectPrompts,\n  discoverDocPrompts,\n  getObjectPromptDependencies,\n} from \"../prompts/prompts\";\nimport type { DocPrompt } from \"../types\";\nimport { listFilesRecursive, readFileSafe } from \"../utils\";\nimport { analyzeRepo, isSourceFile, isTestFile } from \"../code\";\n\ntype PromptSection = {\n  name: string;\n  title: string;\n  description: string;\n  content: string;\n  absolutePath?: string;\n};\n\nfunction relativeFiles(root: string, files: string[]): string[] {\n  return files.map((file) => path.relative(root, file)).sort();\n}\n\nfunction collectPromptSections(names: readonly string[]): PromptSection[] {\n  const root = getWorkspaceRoot();\n  const promptIndex = new Map<string, DocPrompt>(\n    discoverDocPrompts(root).map((prompt) => [prompt.name, prompt])\n  );\n  return names\n    .map((name) => promptIndex.get(name))\n    .filter((prompt): prompt is DocPrompt => Boolean(prompt))\n    .map((prompt) => ({\n      name: prompt.name,\n      title: prompt.title,\n      description: prompt.description,\n      content: prompt.content,\n      absolutePath: prompt.absolutePath,\n    }));\n}\n\nfunction parseTaskLines(content: string): string[] {\n  return content\n    .split(/\\r?\\n/)\n    .map((line) => line.trim())\n    .filter((line) => /^task\\s+\\d+/i.test(line));\n}\n\nfunction computeCoverageFromFinal(coveragePath: string) {\n  const payload = JSON.parse(fs.readFileSync(coveragePath, \"utf8\")) as Record<\n    string,\n    {\n      s: Record<string, number>;\n      f: Record<string, number>;\n      b: Record<string, number | number[]>;\n    }\n  >;\n\n  const totals = {\n    statements: { covered: 0, total: 0 },\n    functions: { covered: 0, total: 0 },\n    branches: { covered: 0, total: 0 },\n  };\n\n  const files = Object.entries(payload).map(([filePath, info]) => {\n    const statementCounts = Object.values(info.s);\n    const functionCounts = Object.values(info.f);\n    const branchCounts = Object.values(info.b).flatMap((value) =>\n      Array.isArray(value) ? value : [value]\n    );\n\n    const statementTotal = statementCounts.length;\n    const functionTotal = functionCounts.length;\n    const branchTotal = branchCounts.length;\n\n    const statementCovered = statementCounts.filter(\n      (count) => count > 0\n    ).length;\n    const functionCovered = functionCounts.filter((count) => count > 0).length;\n    const branchCovered = branchCounts.filter((count) => count > 0).length;\n\n    totals.statements.covered += statementCovered;\n    totals.statements.total += statementTotal;\n    totals.functions.covered += functionCovered;\n    totals.functions.total += functionTotal;\n    totals.branches.covered += branchCovered;\n    totals.branches.total += branchTotal;\n\n    const pct = (covered: number, total: number) =>\n      total === 0 ? 100 : Number(((covered / total) * 100).toFixed(2));\n\n    return {\n      path: filePath,\n      statements: pct(statementCovered, statementTotal),\n      functions: pct(functionCovered, functionTotal),\n      branches: pct(branchCovered, branchTotal),\n    };\n  });\n\n  const pct = (covered: number, total: number) =>\n    total === 0 ? 100 : Number(((covered / total) * 100).toFixed(2));\n\n  return {\n    totals: {\n      statements: {\n        ...totals.statements,\n        pct: pct(totals.statements.covered, totals.statements.total),\n      },\n      functions: {\n        ...totals.functions,\n        pct: pct(totals.functions.covered, totals.functions.total),\n      },\n      branches: {\n        ...totals.branches,\n        pct: pct(totals.branches.covered, totals.branches.total),\n      },\n    },\n    files,\n  };\n}\n\nfunction normalizePromptSections(sections: PromptSection[]) {\n  return sections.map((section) => ({\n    name: section.name,\n    title: section.title,\n    tasks: parseTaskLines(section.content),\n    content: section.content,\n  }));\n}\n\nasync function resolveRepoRoot(basePath: string) {\n  const root = getWorkspaceRoot();\n  try {\n    return resolveInWorkspace(root, basePath);\n  } catch (error) {\n    if (error instanceof WorkspaceError) {\n      await throwUserError(error.message);\n    }\n    throw error;\n  }\n}\n\nexport const documentObjectTool: Tool<undefined, typeof documentObjectSchema> =\n  {\n    name: \"document-object\",\n    description:\n      \"Create a documentation plan for a specific object type using .codex prompts and repository analysis.\",\n    parameters: documentObjectSchema,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    execute: async (input, _context): Promise<ContentResult> => {\n      const args = documentObjectSchema.parse(input as DocumentObjectArgs);\n      const repoRoot = await resolveRepoRoot(args.basePath);\n\n      const dependencies = getObjectPromptDependencies()[args.objectType] ?? [];\n      if (!dependencies.length) {\n        await throwUserError(\n          `No prompt guidance configured for object type ${args.objectType}`\n        );\n      }\n\n      const sections = normalizePromptSections(\n        collectPromptSections(dependencies)\n      );\n\n      const srcDir = path.join(repoRoot, \"src\");\n      const testDir = path.join(repoRoot, \"tests\");\n\n      const sourceFiles = fs.existsSync(srcDir)\n        ? listFilesRecursive(srcDir, isSourceFile)\n        : [];\n      const testFiles = fs.existsSync(testDir)\n        ? listFilesRecursive(\n            testDir,\n            (file) => isSourceFile(file) && isTestFile(file)\n          )\n        : [];\n\n      let targetFileContent: string | undefined;\n      if (args.targetFile) {\n        try {\n          const absolute = resolveInWorkspace(repoRoot, args.targetFile);\n          targetFileContent = readFileSafe(absolute) ?? undefined;\n        } catch (error) {\n          if (error instanceof WorkspaceError) {\n            await throwUserError(error.message);\n          }\n          throw error;\n        }\n      }\n\n      const payload = {\n        basePath: path.relative(getWorkspaceRoot(), repoRoot) || \".\",\n        objectType: args.objectType,\n        targetFile: args.targetFile,\n        guidance: sections,\n        files: {\n          source: relativeFiles(repoRoot, sourceFiles),\n          tests: relativeFiles(repoRoot, testFiles),\n        },\n        targetFileContent: args.includeContent ? targetFileContent : undefined,\n      };\n\n      return {\n        content: [\n          {\n            type: \"text\",\n            text: JSON.stringify(payload, null, 2),\n          },\n        ],\n      } satisfies ContentResult;\n    },\n  };\n\nexport const coverageEnforcerTool: Tool<undefined, typeof coverageTaskSchema> =\n  {\n    name: \"ensure-test-coverage\",\n    description:\n      \"Run the configured coverage command and report whether the target percentage is met, highlighting weak files.\",\n    parameters: coverageTaskSchema,\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    execute: async (input, _context): Promise<ContentResult> => {\n      const args = coverageTaskSchema.parse(input as CoverageTaskArgs);\n      const repoRoot = await resolveRepoRoot(args.basePath);\n\n      if (!args.dryRun) {\n        const env = {\n          ...process.env,\n          USE_WATCHMAN: \"false\",\n          WATCHMAN_DISABLE: \"1\",\n          JEST_DISABLE_WATCHMAN: \"1\",\n        };\n        const result = spawnSync(\n          \"npm\",\n          [\"run\", \"coverage\", \"--\", \"--watchman=false\", \"--runInBand\"],\n          { cwd: repoRoot, env, encoding: \"utf8\" }\n        );\n\n        if (result.status !== 0) {\n          const message =\n            result.stderr || result.stdout || \"Coverage command failed\";\n          await throwUserError(message.trim());\n        }\n      }\n\n      const coveragePath = path.join(\n        repoRoot,\n        \"workdocs\",\n        \"reports\",\n        \"coverage\",\n        \"coverage-final.json\"\n      );\n\n      if (!fs.existsSync(coveragePath)) {\n        await throwUserError(\n          `Coverage report not found at ${path.relative(repoRoot, coveragePath)}`\n        );\n      }\n\n      const summary = computeCoverageFromFinal(coveragePath);\n      const meetsThreshold =\n        summary.totals.statements.pct >= args.coverage &&\n        summary.totals.functions.pct >= args.coverage &&\n        summary.totals.branches.pct >= args.coverage;\n\n      const weakest = [...summary.files]\n        .sort((a, b) => a.statements - b.statements)\n        .slice(0, 10);\n\n      const guidance = normalizePromptSections(\n        collectPromptSections([\"bulk-tests\"])\n      );\n\n      const payload = {\n        basePath: path.relative(getWorkspaceRoot(), repoRoot) || \".\",\n        target: args.coverage,\n        meetsThreshold,\n        totals: summary.totals,\n        weakest,\n        guidance,\n      };\n\n      return {\n        content: [\n          {\n            type: \"text\",\n            text: JSON.stringify(payload, null, 2),\n          },\n        ],\n      } satisfies ContentResult;\n    },\n  };\n\nexport const readmeImprovementTool: Tool<\n  undefined,\n  typeof readmeImprovementSchema\n> = {\n  name: \"improve-readme\",\n  description:\n    \"Summarize required steps to refresh README and workdocs content using .codex guidance and repository analysis.\",\n  parameters: readmeImprovementSchema,\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  execute: async (input, _context): Promise<ContentResult> => {\n    const args = readmeImprovementSchema.parse(input as ReadmeImprovementArgs);\n    const repoRoot = await resolveRepoRoot(args.basePath);\n\n    const analysis = analyzeRepo(repoRoot);\n    const modules = analysis.files\n      .filter((file) => /index\\.ts$/.test(file))\n      .map((file) => path.relative(repoRoot, file));\n\n    const promptSections = normalizePromptSections(\n      collectPromptSections([\"update-readme\", \"doc\", \"module\"])\n    );\n\n    const testExamples = Object.keys(analysis.tests ?? {});\n    const examples = args.includeExamples ? testExamples.slice(0, 20) : [];\n\n    const payload = {\n      basePath: path.relative(getWorkspaceRoot(), repoRoot) || \".\",\n      summary: {\n        modules,\n        totalSourceFiles: analysis.files.length,\n        totalTestFiles: analysis.testFiles.length,\n        hasReadme: Boolean(analysis.readme),\n      },\n      guidance: promptSections,\n      suggestedExamples: examples,\n    };\n\n    return {\n      content: [\n        {\n          type: \"text\",\n          text: JSON.stringify(payload, null, 2),\n        },\n      ],\n    } satisfies ContentResult;\n  },\n};\n"]}

package/lib/esm/mcp/tools/generateMcpModule.d.ts

@@ -0,0 +1,9 @@
+import type { Tool } from "fastmcp";
+import { z } from "zod";
+declare const generateSchema: z.ZodObject<{
+    repoPath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    moduleName: z.ZodOptional<z.ZodString>;
+    includeDocs: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const generateMcpModuleTool: Tool<undefined, typeof generateSchema>;
+export default generateMcpModuleTool;

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

@@ -0,0 +1,133 @@
+// New tool: generate-mcp-module
+import fs from "fs";
+import path from "path";
+import { z } from "zod";
+import { getWorkspaceRoot } from "../workspace";
+import { analyzeRepo } from "../code";
+import { scaffoldModule } from "../validation/scaffoldModule";
+const generateSchema = z.object({
+    repoPath: z.string().optional().default("."),
+    moduleName: z.string().optional(),
+    includeDocs: z.boolean().default(true),
+});
+export const generateMcpModuleTool = {
+    name: "generate-mcp-module",
+    description: "Generate a minimal MCP module under src/modules/<name> by analyzing a target repository and exporting prompts, resources, templates and tools.",
+    parameters: generateSchema,
+    execute: async (input) => {
+        const args = generateSchema.parse(input);
+        const root = getWorkspaceRoot();
+        let repoRoot = path.resolve(process.cwd(), args.repoPath || ".");
+        if (!fs.existsSync(repoRoot)) {
+            const alt = path.resolve(process.cwd(), "..", args.repoPath);
+            if (fs.existsSync(alt))
+                repoRoot = alt;
+        }
+        if (!fs.existsSync(repoRoot)) {
+            const alt2 = path.resolve(process.cwd(), "..", path.basename(args.repoPath));
+            if (fs.existsSync(alt2))
+                repoRoot = alt2;
+        }
+        if (!fs.existsSync(repoRoot))
+            throw new Error(`Repository not found at ${repoRoot}`);
+        const analysis = analyzeRepo(repoRoot);
+        const inferredName = args.moduleName ?? path.basename(path.resolve(repoRoot));
+        const moduleRoot = path.join(root, "src", "modules", inferredName);
+        // Use existing scaffold to create folders
+        scaffoldModule(root, inferredName);
+        // populate prompts: copy markdown prompts from README.md and docs/
+        const promptsDir = path.join(moduleRoot, "prompts");
+        const resourcesDir = path.join(moduleRoot, "resources");
+        const templatesDir = path.join(moduleRoot, "templates");
+        const toolsDir = path.join(moduleRoot, "tools");
+        // helper to write an index.ts that exports arrays
+        function writeIndex(dir, varName, items) {
+            const p = path.join(dir, "index.ts");
+            const content = `export const ${varName} = ${items} as const;\n`;
+            fs.writeFileSync(p, content, { encoding: "utf8" });
+        }
+        // Prompts: create a simple prompt from README and any .md in docs
+        const promptAssets = [];
+        if (args.includeDocs) {
+            const readme = path.join(repoRoot, "README.md");
+            if (fs.existsSync(readme)) {
+                const content = fs.readFileSync(readme, "utf8");
+                const id = "readme";
+                const promptPath = path.join(promptsDir, `${id}.md`);
+                fs.writeFileSync(promptPath, content, { encoding: "utf8" });
+                promptAssets.push({
+                    id,
+                    title: "README",
+                    description: "Repository README",
+                    absolutePath: promptPath,
+                    load: () => content,
+                });
+            }
+            const docsDir = path.join(repoRoot, "docs");
+            if (fs.existsSync(docsDir) && fs.statSync(docsDir).isDirectory()) {
+                for (const f of fs.readdirSync(docsDir)) {
+                    if (!f.endsWith(".md"))
+                        continue;
+                    const content = fs.readFileSync(path.join(docsDir, f), "utf8");
+                    const id = path.parse(f).name;
+                    const promptPath = path.join(promptsDir, `${id}.md`);
+                    fs.writeFileSync(promptPath, content, { encoding: "utf8" });
+                    promptAssets.push({
+                        id,
+                        title: id,
+                        description: content.split(/\r?\n/)[0] || "",
+                        absolutePath: promptPath,
+                        load: () => content,
+                    });
+                }
+            }
+        }
+        writeIndex(promptsDir, "prompts", JSON.stringify(promptAssets, null, 2));
+        // Resources: reference the repo root and docs
+        const resourceAssets = [
+            {
+                id: `${inferredName}.repo`,
+                name: `${inferredName} repository`,
+                description: "Source repository",
+                uri: `file://${repoRoot}`,
+                absolutePath: repoRoot,
+            },
+        ];
+        writeIndex(resourcesDir, "resources", JSON.stringify(resourceAssets, null, 2));
+        // Templates: create a placeholder template that references README
+        const templateAssets = [
+            {
+                name: "readme-template",
+                description: "README as guidance",
+                uriTemplate: `file://${path.join(repoRoot, "README.md")}`,
+                mimeType: "text/markdown",
+            },
+        ];
+        writeIndex(templatesDir, "templates", JSON.stringify(templateAssets, null, 2));
+        // Tools: create a wrapper tool that exposes analyze/enumerate for the module
+        const toolIndexPath = path.join(toolsDir, "index.ts");
+        const toolContent = `import type { Tool } from 'fastmcp';\nimport { buildAnalyzeRepositoryTool, buildEnumerateCapabilitiesTool, buildPlanFeatureTool } from '../../../mcp/tools/tools';\nexport const tools = [\n  { id: '${inferredName}.analyze', title: 'Analyze ${inferredName}', description: 'Analyze the target repository', tool: buildAnalyzeRepositoryTool() },\n  { id: '${inferredName}.enumerate', title: 'Enumerate capabilities for ${inferredName}', description: 'Enumerate capabilities', tool: buildEnumerateCapabilitiesTool() },\n  { id: '${inferredName}.plan', title: 'Plan features for ${inferredName}', description: 'Plan feature implementation', tool: buildPlanFeatureTool() },\n] as const;\n`;
+        fs.writeFileSync(toolIndexPath, toolContent, { encoding: "utf8" });
+        // Write module index.ts
+        const moduleIndex = path.join(moduleRoot, "index.ts");
+        const moduleIndexContent = `import { prompts } from './prompts';\nimport { resources } from './resources';\nimport { templates } from './templates';\nimport { tools } from './tools';\nexport { prompts } from './prompts';\nexport { resources } from './resources';\nexport { templates } from './templates';\nexport { tools } from './tools';\nexport const modulePackage = { name: '${inferredName}', prompts, resources, templates, tools } as const;\n`;
+        fs.writeFileSync(moduleIndex, moduleIndexContent, { encoding: "utf8" });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        moduleRoot,
+                        inferredName,
+                        analysisSummary: {
+                            files: analysis.files.length,
+                            testFiles: analysis.testFiles.length,
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+};
+export default generateMcpModuleTool;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generateMcpModule.js","sourceRoot":"","sources":["../../../../src/mcp/tools/generateMcpModule.ts"],"names":[],"mappings":"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","sourcesContent":["// New tool: generate-mcp-module\nimport fs from \"fs\";\nimport path from \"path\";\nimport type { Tool } from \"fastmcp\";\nimport { z } from \"zod\";\nimport { getWorkspaceRoot } from \"../workspace\";\nimport { analyzeRepo } from \"../code\";\nimport { scaffoldModule } from \"../validation/scaffoldModule\";\n\nconst generateSchema = z.object({\n  repoPath: z.string().optional().default(\".\"),\n  moduleName: z.string().optional(),\n  includeDocs: z.boolean().default(true),\n});\n\ntype GenerateArgs = z.infer<typeof generateSchema>;\n\nexport const generateMcpModuleTool: Tool<undefined, typeof generateSchema> = {\n  name: \"generate-mcp-module\",\n  description:\n    \"Generate a minimal MCP module under src/modules/<name> by analyzing a target repository and exporting prompts, resources, templates and tools.\",\n  parameters: generateSchema,\n  execute: async (input) => {\n    const args = generateSchema.parse(input as any);\n    const root = getWorkspaceRoot();\n    let repoRoot = path.resolve(process.cwd(), args.repoPath || \".\");\n    if (!fs.existsSync(repoRoot)) {\n      const alt = path.resolve(process.cwd(), \"..\", args.repoPath);\n      if (fs.existsSync(alt)) repoRoot = alt;\n    }\n    if (!fs.existsSync(repoRoot)) {\n      const alt2 = path.resolve(\n        process.cwd(),\n        \"..\",\n        path.basename(args.repoPath)\n      );\n      if (fs.existsSync(alt2)) repoRoot = alt2;\n    }\n    if (!fs.existsSync(repoRoot))\n      throw new Error(`Repository not found at ${repoRoot}`);\n\n    const analysis = analyzeRepo(repoRoot);\n    const inferredName =\n      args.moduleName ?? path.basename(path.resolve(repoRoot));\n    const moduleRoot = path.join(root, \"src\", \"modules\", inferredName);\n\n    // Use existing scaffold to create folders\n    scaffoldModule(root, inferredName);\n\n    // populate prompts: copy markdown prompts from README.md and docs/\n    const promptsDir = path.join(moduleRoot, \"prompts\");\n    const resourcesDir = path.join(moduleRoot, \"resources\");\n    const templatesDir = path.join(moduleRoot, \"templates\");\n    const toolsDir = path.join(moduleRoot, \"tools\");\n\n    // helper to write an index.ts that exports arrays\n    function writeIndex(dir: string, varName: string, items: string) {\n      const p = path.join(dir, \"index.ts\");\n      const content = `export const ${varName} = ${items} as const;\\n`;\n      fs.writeFileSync(p, content, { encoding: \"utf8\" });\n    }\n\n    // Prompts: create a simple prompt from README and any .md in docs\n    const promptAssets: any[] = [];\n    if (args.includeDocs) {\n      const readme = path.join(repoRoot, \"README.md\");\n      if (fs.existsSync(readme)) {\n        const content = fs.readFileSync(readme, \"utf8\");\n        const id = \"readme\";\n        const promptPath = path.join(promptsDir, `${id}.md`);\n        fs.writeFileSync(promptPath, content, { encoding: \"utf8\" });\n        promptAssets.push({\n          id,\n          title: \"README\",\n          description: \"Repository README\",\n          absolutePath: promptPath,\n          load: () => content,\n        });\n      }\n      const docsDir = path.join(repoRoot, \"docs\");\n      if (fs.existsSync(docsDir) && fs.statSync(docsDir).isDirectory()) {\n        for (const f of fs.readdirSync(docsDir)) {\n          if (!f.endsWith(\".md\")) continue;\n          const content = fs.readFileSync(path.join(docsDir, f), \"utf8\");\n          const id = path.parse(f).name;\n          const promptPath = path.join(promptsDir, `${id}.md`);\n          fs.writeFileSync(promptPath, content, { encoding: \"utf8\" });\n          promptAssets.push({\n            id,\n            title: id,\n            description: content.split(/\\r?\\n/)[0] || \"\",\n            absolutePath: promptPath,\n            load: () => content,\n          });\n        }\n      }\n    }\n\n    writeIndex(promptsDir, \"prompts\", JSON.stringify(promptAssets, null, 2));\n\n    // Resources: reference the repo root and docs\n    const resourceAssets = [\n      {\n        id: `${inferredName}.repo`,\n        name: `${inferredName} repository`,\n        description: \"Source repository\",\n        uri: `file://${repoRoot}`,\n        absolutePath: repoRoot,\n      },\n    ];\n    writeIndex(\n      resourcesDir,\n      \"resources\",\n      JSON.stringify(resourceAssets, null, 2)\n    );\n\n    // Templates: create a placeholder template that references README\n    const templateAssets = [\n      {\n        name: \"readme-template\",\n        description: \"README as guidance\",\n        uriTemplate: `file://${path.join(repoRoot, \"README.md\")}`,\n        mimeType: \"text/markdown\",\n      },\n    ];\n    writeIndex(\n      templatesDir,\n      \"templates\",\n      JSON.stringify(templateAssets, null, 2)\n    );\n\n    // Tools: create a wrapper tool that exposes analyze/enumerate for the module\n    const toolIndexPath = path.join(toolsDir, \"index.ts\");\n    const toolContent = `import type { Tool } from 'fastmcp';\\nimport { buildAnalyzeRepositoryTool, buildEnumerateCapabilitiesTool, buildPlanFeatureTool } from '../../../mcp/tools/tools';\\nexport const tools = [\\n  { id: '${inferredName}.analyze', title: 'Analyze ${inferredName}', description: 'Analyze the target repository', tool: buildAnalyzeRepositoryTool() },\\n  { id: '${inferredName}.enumerate', title: 'Enumerate capabilities for ${inferredName}', description: 'Enumerate capabilities', tool: buildEnumerateCapabilitiesTool() },\\n  { id: '${inferredName}.plan', title: 'Plan features for ${inferredName}', description: 'Plan feature implementation', tool: buildPlanFeatureTool() },\\n] as const;\\n`;\n    fs.writeFileSync(toolIndexPath, toolContent, { encoding: \"utf8\" });\n\n    // Write module index.ts\n    const moduleIndex = path.join(moduleRoot, \"index.ts\");\n    const moduleIndexContent = `import { prompts } from './prompts';\\nimport { resources } from './resources';\\nimport { templates } from './templates';\\nimport { tools } from './tools';\\nexport { prompts } from './prompts';\\nexport { resources } from './resources';\\nexport { templates } from './templates';\\nexport { tools } from './tools';\\nexport const modulePackage = { name: '${inferredName}', prompts, resources, templates, tools } as const;\\n`;\n    fs.writeFileSync(moduleIndex, moduleIndexContent, { encoding: \"utf8\" });\n\n    return {\n      content: [\n        {\n          type: \"text\",\n          text: JSON.stringify(\n            {\n              moduleRoot,\n              inferredName,\n              analysisSummary: {\n                files: analysis.files.length,\n                testFiles: analysis.testFiles.length,\n              },\n            },\n            null,\n            2\n          ),\n        },\n      ],\n    };\n  },\n};\n\nexport default generateMcpModuleTool;\n"]}