@decaf-ts/mcp-server 0.0.4 → 0.2.0

package/lib/mcp/types.d.ts

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

package/lib/mcp/utils.cjs

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readFileSafe = readFileSafe;
+exports.listFilesRecursive = listFilesRecursive;
+exports.deriveCapabilities = deriveCapabilities;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function readFileSafe(filePath, encoding = "utf8") {
+    try {
+        return fs_1.default.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_1.default.statSync(cur);
+        if (stat.isDirectory()) {
+            for (const f of fs_1.default.readdirSync(cur))
+                stack.push(path_1.default.join(cur, f));
+        }
+        else if (!matcher || matcher(cur)) {
+            out.push(cur);
+        }
+    }
+    return out.sort();
+}
+function deriveCapabilities(analysis) {
+    const cap = new Set();
+    // heuristics: if decorators like Decoration, flavouredAs, extend, override appear, add capabilities
+    const allDecs = new Set();
+    for (const k of Object.keys(analysis.api)) {
+        for (const d of analysis.api[k].decorators)
+            allDecs.add(d);
+        for (const e of analysis.api[k].exports)
+            if (/Decoration|decorate|Builder|Flavour/i.test(e))
+                cap.add("use-decoration-api");
+    }
+    if ([...allDecs].some((d) => /override|extend/i.test(d)))
+        cap.add("override-and-extend-decorations");
+    if (Object.keys(analysis.tests).length > 0)
+        cap.add("validate-with-tests");
+    if (analysis.readme)
+        cap.add("follow-readme-guides");
+    return [...cap].sort();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp/utils.d.ts

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

package/lib/mcp/validation/index.cjs

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findModuleDirs = findModuleDirs;
+exports.validateModules = validateModules;
+// New: validation entrypoint for module structure
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const REQUIRED_SUBFOLDERS = ["prompts", "resources", "templates", "tools"];
+function findModuleDirs(repoRoot) {
+    const modulesPath = path_1.default.resolve(repoRoot, "src", "modules");
+    if (!fs_1.default.existsSync(modulesPath) || !fs_1.default.statSync(modulesPath).isDirectory()) {
+        return [];
+    }
+    return fs_1.default
+        .readdirSync(modulesPath, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => path_1.default.join(modulesPath, d.name));
+}
+function hasIndexExport(folderPath) {
+    const candidates = [
+        "index.ts",
+        "index.tsx",
+        "index.js",
+        "index.cjs",
+        "index.mjs",
+    ];
+    for (const c of candidates) {
+        if (fs_1.default.existsSync(path_1.default.join(folderPath, c)))
+            return true;
+    }
+    return false;
+}
+function validateModules(repoRoot) {
+    const dirs = findModuleDirs(repoRoot);
+    const issues = [];
+    for (const moduleDir of dirs) {
+        const moduleName = path_1.default.basename(moduleDir);
+        for (const sub of REQUIRED_SUBFOLDERS) {
+            const subPath = path_1.default.join(moduleDir, sub);
+            if (!fs_1.default.existsSync(subPath) || !fs_1.default.statSync(subPath).isDirectory()) {
+                issues.push({
+                    module: moduleName,
+                    path: subPath,
+                    type: "missing-folder",
+                    detail: `Required folder '${sub}' is missing in module '${moduleName}'`,
+                });
+                continue;
+            }
+            // If folder exists, check for index export
+            if (!hasIndexExport(subPath)) {
+                issues.push({
+                    module: moduleName,
+                    path: subPath,
+                    type: "missing-export",
+                    detail: `No index export found in '${subPath}'. Expected one of index.ts, index.js, etc.`,
+                });
+                continue;
+            }
+            // Optionally inspect the index file to see if it exports a list (lightweight check)
+            try {
+                const indexFile = candidatesFindingIndex(subPath);
+                if (indexFile) {
+                    const content = fs_1.default.readFileSync(indexFile, "utf8");
+                    // crude heuristics: look for `export const name = [` or `export const name: Type[] = [`,
+                    // or any named export like `export { something }` which implies exports exist.
+                    const exportListPattern = /export\s+(const|let|var)\s+[\w$]+(?:\s*:\s*[^=]+)?\s*=\s*\[/;
+                    if (!exportListPattern.test(content) &&
+                        !/export\s+\{/.test(content)) {
+                        issues.push({
+                            module: moduleName,
+                            path: indexFile,
+                            type: "empty-list",
+                            detail: `Index file does not appear to export a list of assets: ${path_1.default.basename(indexFile)}`,
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                issues.push({
+                    module: moduleName,
+                    path: subPath,
+                    type: "other",
+                    detail: `Error reading index file: ${err.message}`,
+                });
+            }
+        }
+    }
+    return {
+        ok: issues.length === 0,
+        modulesChecked: dirs.length,
+        issues,
+    };
+}
+function candidatesFindingIndex(folderPath) {
+    const candidates = [
+        "index.ts",
+        "index.tsx",
+        "index.js",
+        "index.cjs",
+        "index.mjs",
+    ];
+    for (const c of candidates) {
+        const full = path_1.default.join(folderPath, c);
+        if (fs_1.default.existsSync(full))
+            return full;
+    }
+    return undefined;
+}
+// CLI helper
+if (require.main === module) {
+    const repoRoot = process.cwd();
+    const report = validateModules(repoRoot);
+    if (!report.ok) {
+        console.error("Module validation failed:\n", JSON.stringify(report, null, 2));
+        process.exit(2);
+    }
+    console.log("Module validation passed");
+    process.exit(0);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/mcp/validation/index.ts"],"names":[],"mappings":"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","sourcesContent":["// New: validation entrypoint for module structure\nimport fs from \"fs\";\nimport path from \"path\";\n\nexport type ValidationIssue = {\n  module: string;\n  path: string;\n  type:\n    | \"missing-folder\"\n    | \"missing-export\"\n    | \"empty-list\"\n    | \"disabled\"\n    | \"other\";\n  detail?: string;\n};\n\nexport type ValidationReport = {\n  ok: boolean;\n  modulesChecked: number;\n  issues: ValidationIssue[];\n};\n\nconst REQUIRED_SUBFOLDERS = [\"prompts\", \"resources\", \"templates\", \"tools\"];\n\nexport function findModuleDirs(repoRoot: string): string[] {\n  const modulesPath = path.resolve(repoRoot, \"src\", \"modules\");\n  if (!fs.existsSync(modulesPath) || !fs.statSync(modulesPath).isDirectory()) {\n    return [];\n  }\n  return fs\n    .readdirSync(modulesPath, { withFileTypes: true })\n    .filter((d) => d.isDirectory())\n    .map((d) => path.join(modulesPath, d.name));\n}\n\nfunction hasIndexExport(folderPath: string): boolean {\n  const candidates = [\n    \"index.ts\",\n    \"index.tsx\",\n    \"index.js\",\n    \"index.cjs\",\n    \"index.mjs\",\n  ];\n  for (const c of candidates) {\n    if (fs.existsSync(path.join(folderPath, c))) return true;\n  }\n  return false;\n}\n\nexport function validateModules(repoRoot: string): ValidationReport {\n  const dirs = findModuleDirs(repoRoot);\n  const issues: ValidationIssue[] = [];\n\n  for (const moduleDir of dirs) {\n    const moduleName = path.basename(moduleDir);\n    for (const sub of REQUIRED_SUBFOLDERS) {\n      const subPath = path.join(moduleDir, sub);\n      if (!fs.existsSync(subPath) || !fs.statSync(subPath).isDirectory()) {\n        issues.push({\n          module: moduleName,\n          path: subPath,\n          type: \"missing-folder\",\n          detail: `Required folder '${sub}' is missing in module '${moduleName}'`,\n        });\n        continue;\n      }\n      // If folder exists, check for index export\n      if (!hasIndexExport(subPath)) {\n        issues.push({\n          module: moduleName,\n          path: subPath,\n          type: \"missing-export\",\n          detail: `No index export found in '${subPath}'. Expected one of index.ts, index.js, etc.`,\n        });\n        continue;\n      }\n      // Optionally inspect the index file to see if it exports a list (lightweight check)\n      try {\n        const indexFile = candidatesFindingIndex(subPath);\n        if (indexFile) {\n          const content = fs.readFileSync(indexFile, \"utf8\");\n          // crude heuristics: look for `export const name = [` or `export const name: Type[] = [`,\n          // or any named export like `export { something }` which implies exports exist.\n          const exportListPattern =\n            /export\\s+(const|let|var)\\s+[\\w$]+(?:\\s*:\\s*[^=]+)?\\s*=\\s*\\[/;\n          if (\n            !exportListPattern.test(content) &&\n            !/export\\s+\\{/.test(content)\n          ) {\n            issues.push({\n              module: moduleName,\n              path: indexFile,\n              type: \"empty-list\",\n              detail: `Index file does not appear to export a list of assets: ${path.basename(indexFile)}`,\n            });\n          }\n        }\n      } catch (err: any) {\n        issues.push({\n          module: moduleName,\n          path: subPath,\n          type: \"other\",\n          detail: `Error reading index file: ${err.message}`,\n        });\n      }\n    }\n  }\n\n  return {\n    ok: issues.length === 0,\n    modulesChecked: dirs.length,\n    issues,\n  };\n}\n\nfunction candidatesFindingIndex(folderPath: string): string | undefined {\n  const candidates = [\n    \"index.ts\",\n    \"index.tsx\",\n    \"index.js\",\n    \"index.cjs\",\n    \"index.mjs\",\n  ];\n  for (const c of candidates) {\n    const full = path.join(folderPath, c);\n    if (fs.existsSync(full)) return full;\n  }\n  return undefined;\n}\n\n// CLI helper\nif (require.main === module) {\n  const repoRoot = process.cwd();\n  const report = validateModules(repoRoot);\n  if (!report.ok) {\n    console.error(\n      \"Module validation failed:\\n\",\n      JSON.stringify(report, null, 2)\n    );\n    process.exit(2);\n  }\n  console.log(\"Module validation passed\");\n  process.exit(0);\n}\n"]}

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

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

package/lib/mcp/validation/scaffoldModule.cjs

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scaffoldModule = scaffoldModule;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const DEFAULT_PLACEHOLDERS = {
+    prompts: `export const promptList = [
+  {
+    id: "example-prompt",
+    title: "Example prompt",
+    description: "A placeholder prompt created by scaffoldModule",
+    content: "Describe the task for the assistant...",
+    absolutePath: __filename,
+  },
+] as const;
+`,
+    resources: `export const resources = [
+  {
+    id: "example-resource",
+    name: "Example Resource",
+    description: "A placeholder resource created by scaffoldModule",
+    uri: "file://placeholder",
+    absolutePath: __filename,
+  },
+] as const;
+`,
+    templates: `export const templates = [
+  {
+    name: "example-template",
+    description: "A placeholder template created by scaffoldModule",
+    uriTemplate: "file://template/{path}",
+    mimeType: "text/plain",
+  },
+] as const;
+`,
+    tools: `export const toolList = [
+  {
+    id: "example-tool",
+    name: "example-tool",
+    description: "A placeholder tool created by scaffoldModule",
+    run: async () => ({ result: "placeholder" }),
+  },
+] as const;
+`,
+};
+/**
+ * Create a module scaffold under repoRoot/src/modules/<moduleName>
+ * Returns created files list.
+ */
+function scaffoldModule(repoRoot, moduleName) {
+    if (!repoRoot)
+        throw new Error("repoRoot is required");
+    if (!moduleName)
+        throw new Error("moduleName is required");
+    const modulePath = path_1.default.join(repoRoot, "src", "modules", moduleName);
+    const createdFiles = [];
+    const subfolders = ["prompts", "resources", "templates", "tools"];
+    for (const folder of subfolders) {
+        const folderPath = path_1.default.join(modulePath, folder);
+        fs_1.default.mkdirSync(folderPath, { recursive: true });
+        const indexPath = path_1.default.join(folderPath, "index.ts");
+        // if file exists, skip writing
+        if (!fs_1.default.existsSync(indexPath)) {
+            // insert __filename for absolutePath in placeholders
+            const content = DEFAULT_PLACEHOLDERS[folder].replace(/__filename/g, JSON.stringify(indexPath));
+            fs_1.default.writeFileSync(indexPath, content, { encoding: "utf8" });
+            createdFiles.push(indexPath);
+        }
+    }
+    return { modulePath, createdFiles };
+}
+// CLI support when required directly via ts-node registration
+if (require.main === module) {
+    const [, , moduleName] = process.argv;
+    if (!moduleName) {
+        console.error("Usage: scaffold-module <module-name>");
+        process.exit(1);
+    }
+    try {
+        const res = scaffoldModule(process.cwd(), moduleName);
+        console.log("Scaffolded module:", res.modulePath);
+        for (const f of res.createdFiles)
+            console.log("  created:", f);
+        process.exit(0);
+    }
+    catch (err) {
+        console.error(err && err.message ? err.message : err);
+        process.exit(2);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/lib/mcp/workspace.cjs

@@ -0,0 +1,119 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceError = void 0;
+exports.throwUserError = throwUserError;
+exports.setWorkspaceRoot = setWorkspaceRoot;
+exports.getWorkspaceRoot = getWorkspaceRoot;
+exports.resolveInWorkspace = resolveInWorkspace;
+exports.readWorkspaceFile = readWorkspaceFile;
+exports.__resetWorkspaceRoot = __resetWorkspaceRoot;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("./../constants.cjs");
+let workspaceRoot = initializeWorkspaceRoot();
+let userErrorCtor;
+class WorkspaceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WorkspaceError";
+    }
+}
+exports.WorkspaceError = WorkspaceError;
+function initializeWorkspaceRoot() {
+    const configured = process.env[constants_1.WORKSPACE_ROOT_ENV];
+    if (configured && configured.trim().length > 0) {
+        return path_1.default.resolve(configured.trim());
+    }
+    return process.cwd();
+}
+async function getUserErrorCtor() {
+    if (!userErrorCtor) {
+        try {
+            const mod = await Promise.resolve().then(() => __importStar(require("fastmcp")));
+            userErrorCtor = mod
+                .UserError;
+        }
+        catch {
+            userErrorCtor = class MCPUserError extends Error {
+                constructor(message) {
+                    super(message);
+                    this.name = "MCPUserError";
+                }
+            };
+        }
+    }
+    return userErrorCtor;
+}
+async function throwUserError(message) {
+    const Ctor = await getUserErrorCtor();
+    throw new Ctor(message);
+}
+function setWorkspaceRoot(root) {
+    workspaceRoot = path_1.default.resolve(root);
+}
+function getWorkspaceRoot() {
+    return workspaceRoot;
+}
+function resolveInWorkspace(root, targetPath) {
+    const resolved = path_1.default.isAbsolute(targetPath)
+        ? path_1.default.normalize(targetPath)
+        : path_1.default.resolve(root, targetPath);
+    const relative = path_1.default.relative(root, resolved);
+    if (relative.startsWith("..") || path_1.default.isAbsolute(relative)) {
+        throw new WorkspaceError(`Path ${targetPath} escapes the workspace root at ${root}`);
+    }
+    return resolved;
+}
+async function readWorkspaceFile(root, target) {
+    try {
+        const absolute = resolveInWorkspace(root, target);
+        return fs_1.default.readFileSync(absolute, "utf8");
+    }
+    catch (error) {
+        if (error instanceof WorkspaceError) {
+            await throwUserError(error.message);
+        }
+        /* istanbul ignore next */
+        throw error;
+    }
+}
+function __resetWorkspaceRoot(root) {
+    setWorkspaceRoot(root);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp/workspace.d.ts

@@ -0,0 +1,9 @@
+export declare class WorkspaceError extends Error {
+    constructor(message: string);
+}
+export declare function throwUserError(message: string): Promise<never>;
+export declare function setWorkspaceRoot(root: string): void;
+export declare function getWorkspaceRoot(): string;
+export declare function resolveInWorkspace(root: string, targetPath: string): string;
+export declare function readWorkspaceFile(root: string, target: string): Promise<string>;
+export declare function __resetWorkspaceRoot(root: string): void;

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.3";
+exports.VERSION = "0.1.0";
 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.3";
+export declare const VERSION = "0.1.0";
 export declare const PACKAGE_NAME = "##PACKAGE_NAME##";

package/lib/modules/_template/index.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modulePackage = exports.tools = exports.templates = exports.resources = exports.prompts = void 0;
+const prompts_1 = require("./prompts/index.cjs");
+const resources_1 = require("./resources/index.cjs");
+const templates_1 = require("./templates/index.cjs");
+const tools_1 = require("./tools/index.cjs");
+var prompts_2 = require("./prompts/index.cjs");
+Object.defineProperty(exports, "prompts", { enumerable: true, get: function () { return prompts_2.prompts; } });
+var resources_2 = require("./resources/index.cjs");
+Object.defineProperty(exports, "resources", { enumerable: true, get: function () { return resources_2.resources; } });
+var templates_2 = require("./templates/index.cjs");
+Object.defineProperty(exports, "templates", { enumerable: true, get: function () { return templates_2.templates; } });
+var tools_2 = require("./tools/index.cjs");
+Object.defineProperty(exports, "tools", { enumerable: true, get: function () { return tools_2.tools; } });
+exports.modulePackage = {
+    name: "_template",
+    prompts: prompts_1.prompts,
+    resources: resources_1.resources,
+    templates: templates_1.templates,
+    tools: tools_1.tools,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbW9kdWxlcy9fdGVtcGxhdGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsaURBQW9DO0FBQ3BDLHFEQUF3QztBQUN4QyxxREFBd0M7QUFDeEMsNkNBQWdDO0FBQ2hDLCtDQUFvQztBQUEzQixrR0FBQSxPQUFPLE9BQUE7QUFDaEIsbURBQXdDO0FBQS9CLHNHQUFBLFNBQVMsT0FBQTtBQUNsQixtREFBd0M7QUFBL0Isc0dBQUEsU0FBUyxPQUFBO0FBQ2xCLDJDQUFnQztBQUF2Qiw4RkFBQSxLQUFLLE9BQUE7QUFDRCxRQUFBLGFBQWEsR0FBRztJQUMzQixJQUFJLEVBQUUsV0FBVztJQUNqQixPQUFPLEVBQVAsaUJBQU87SUFDUCxTQUFTLEVBQVQscUJBQVM7SUFDVCxTQUFTLEVBQVQscUJBQVM7SUFDVCxLQUFLLEVBQUwsYUFBSztDQUNHLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBwcm9tcHRzIH0gZnJvbSBcIi4vcHJvbXB0c1wiO1xuaW1wb3J0IHsgcmVzb3VyY2VzIH0gZnJvbSBcIi4vcmVzb3VyY2VzXCI7XG5pbXBvcnQgeyB0ZW1wbGF0ZXMgfSBmcm9tIFwiLi90ZW1wbGF0ZXNcIjtcbmltcG9ydCB7IHRvb2xzIH0gZnJvbSBcIi4vdG9vbHNcIjtcbmV4cG9ydCB7IHByb21wdHMgfSBmcm9tIFwiLi9wcm9tcHRzXCI7XG5leHBvcnQgeyByZXNvdXJjZXMgfSBmcm9tIFwiLi9yZXNvdXJjZXNcIjtcbmV4cG9ydCB7IHRlbXBsYXRlcyB9IGZyb20gXCIuL3RlbXBsYXRlc1wiO1xuZXhwb3J0IHsgdG9vbHMgfSBmcm9tIFwiLi90b29sc1wiO1xuZXhwb3J0IGNvbnN0IG1vZHVsZVBhY2thZ2UgPSB7XG4gIG5hbWU6IFwiX3RlbXBsYXRlXCIsXG4gIHByb21wdHMsXG4gIHJlc291cmNlcyxcbiAgdGVtcGxhdGVzLFxuICB0b29scyxcbn0gYXMgY29uc3Q7XG4iXX0=

package/lib/modules/_template/index.d.ts

@@ -0,0 +1,32 @@
+export { prompts } from "./prompts";
+export { resources } from "./resources";
+export { templates } from "./templates";
+export { tools } from "./tools";
+export declare const modulePackage: {
+    readonly name: "_template";
+    readonly prompts: readonly [{
+        readonly id: "_template.readme";
+        readonly title: "Template README";
+        readonly description: "A README prompt for module template";
+        readonly load: () => string;
+    }];
+    readonly resources: readonly [{
+        readonly id: "_template.repo";
+        readonly name: "template repo";
+        readonly description: "Template resource";
+        readonly uri: "file:///tmp/template";
+    }];
+    readonly templates: readonly [{
+        readonly id: "_template.readme";
+        readonly name: "template-readme";
+        readonly description: "README guidance";
+        readonly uriTemplate: "file:///tmp/template/README.md";
+        readonly mimeType: "text/markdown";
+    }];
+    readonly tools: readonly [{
+        readonly id: "_template.tool";
+        readonly title: "template tool";
+        readonly description: "A placeholder tool";
+        readonly tool: any;
+    }];
+};

package/lib/modules/_template/prompts/index.cjs

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompts = void 0;
+exports.prompts = [
+    {
+        id: "_template.readme",
+        title: "Template README",
+        description: "A README prompt for module template",
+        load: () => "Template prompt content",
+    },
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbW9kdWxlcy9fdGVtcGxhdGUvcHJvbXB0cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBYSxRQUFBLE9BQU8sR0FBRztJQUNyQjtRQUNFLEVBQUUsRUFBRSxrQkFBa0I7UUFDdEIsS0FBSyxFQUFFLGlCQUFpQjtRQUN4QixXQUFXLEVBQUUscUNBQXFDO1FBQ2xELElBQUksRUFBRSxHQUFHLEVBQUUsQ0FBQyx5QkFBeUI7S0FDdEM7Q0FDTyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGNvbnN0IHByb21wdHMgPSBbXG4gIHtcbiAgICBpZDogXCJfdGVtcGxhdGUucmVhZG1lXCIsXG4gICAgdGl0bGU6IFwiVGVtcGxhdGUgUkVBRE1FXCIsXG4gICAgZGVzY3JpcHRpb246IFwiQSBSRUFETUUgcHJvbXB0IGZvciBtb2R1bGUgdGVtcGxhdGVcIixcbiAgICBsb2FkOiAoKSA9PiBcIlRlbXBsYXRlIHByb21wdCBjb250ZW50XCIsXG4gIH0sXG5dIGFzIGNvbnN0O1xuIl19

package/lib/modules/_template/prompts/index.d.ts

@@ -0,0 +1,6 @@
+export declare const prompts: readonly [{
+    readonly id: "_template.readme";
+    readonly title: "Template README";
+    readonly description: "A README prompt for module template";
+    readonly load: () => string;
+}];