@decaf-ts/mcp-server 0.0.4 → 0.2.0

package/lib/esm/mcp/fastmcp-wiring.js

@@ -0,0 +1,56 @@
+import { aggregateModules } from "./aggregateModules";
+import { loadPrompts, promptList } from "./prompts";
+import { toolList } from "./tools";
+import { resources } from "./resources";
+import { buildResourceTemplates } from "./templates";
+/**
+ * Aggregate module assets and register them on the provided FastMCP-like server.
+ * Falls back to built-in lists if aggregation yields none.
+ */
+export async function EnrichCoreWithAggregation(server, repoRoot = process.cwd()) {
+    // First register built-in prompts/tools/resources/templates (legacy behavior)
+    try {
+        loadPrompts();
+        for (const prompt of promptList)
+            server.addPrompt(prompt);
+    }
+    catch (e) {
+        // ignore if loadPrompts not available or fails
+    }
+    try {
+        for (const tool of toolList)
+            server.addTool(tool);
+    }
+    catch (e) { }
+    try {
+        for (const resource of resources)
+            server.addResource(resource);
+    }
+    catch (e) { }
+    try {
+        const templates = buildResourceTemplates();
+        for (const template of templates)
+            server.addResourceTemplate(template);
+    }
+    catch (e) { }
+    // Now aggregate modules and register aggregated assets with provenance
+    const agg = await aggregateModules(repoRoot);
+    for (const p of agg.prompts) {
+        server.addPrompt(p);
+    }
+    for (const t of agg.tools) {
+        server.addTool(t);
+    }
+    for (const r of agg.resources) {
+        server.addResource(r);
+    }
+    for (const tpl of agg.templates) {
+        server.addResourceTemplate(tpl);
+    }
+    // return aggregation summary for calling tests/CI
+    return {
+        modulesChecked: agg.prompts.concat(agg.tools).length,
+        conflicts: agg.conflicts,
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/lib/esm/mcp/index.js

@@ -1,2 +1,26 @@
-export { default, enrich, tools, setWorkspaceRoot, getWorkspaceRoot, buildResourceTemplates, buildDocPrompts, PACKAGE_NAME, VERSION } from "../modules/mcp";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWNwL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxnQkFBZ0IsRUFBRSxzQkFBc0IsRUFBRSxlQUFlLEVBQUUsWUFBWSxFQUFFLE9BQU8sRUFBRSxNQUFNLGdCQUFnQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgZGVmYXVsdCwgZW5yaWNoLCB0b29scywgc2V0V29ya3NwYWNlUm9vdCwgZ2V0V29ya3NwYWNlUm9vdCwgYnVpbGRSZXNvdXJjZVRlbXBsYXRlcywgYnVpbGREb2NQcm9tcHRzLCBQQUNLQUdFX05BTUUsIFZFUlNJT04gfSBmcm9tIFwiLi4vbW9kdWxlcy9tY3BcIjtcbiJdfQ==
+import { loadPrompts, promptList } from "./prompts";
+import { toolList } from "./tools";
+import { resources } from "./resources";
+import { buildResourceTemplates } from "./templates";
+export * from "./mcp-module";
+export { default } from "./mcp-module";
+export { validateModules } from "./validation";
+export { aggregateModules, aggregateModulesSync } from "./aggregateModules";
+export { EnrichCoreWithAggregation } from "./fastmcp-wiring";
+export function EnrichCore(server) {
+    loadPrompts();
+    for (const prompt of promptList) {
+        server.addPrompt(prompt);
+    }
+    for (const tool of toolList) {
+        server.addTool(tool);
+    }
+    for (const resource of resources) {
+        server.addResource(resource);
+    }
+    const templates = buildResourceTemplates();
+    for (const template of templates) {
+        server.addResourceTemplate(template);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,11 @@
+import type { FastMCP } from "fastmcp";
+import { buildDocPrompts, buildPrompts, buildDocumentationPayload, discoverDocPrompts, promptList, refreshPrompts, selectPrompt, DEFAULT_PROMPT_NAME } from "./prompts";
+import { resources } from "./resources";
+import { buildDecorationResourceTemplates, buildResourceTemplates, decorationResourceTemplates, templateList, workspaceResourceTemplates } from "./templates";
+import { toolList, tools } from "./tools";
+import { __resetWorkspaceRoot, getWorkspaceRoot, setWorkspaceRoot } from "./workspace";
+export declare function enrich(mcp: FastMCP): FastMCP;
+export default enrich;
+export declare const PACKAGE_NAME = "##PACKAGE_NAME##";
+export declare const VERSION = "0.1.0";
+export { tools, toolList, buildDocPrompts, buildPrompts, buildDecorationResourceTemplates, buildResourceTemplates, buildDocumentationPayload, decorationResourceTemplates, discoverDocPrompts, DEFAULT_PROMPT_NAME, promptList, refreshPrompts, resources, selectPrompt, templateList, workspaceResourceTemplates, getWorkspaceRoot, setWorkspaceRoot, __resetWorkspaceRoot, };

package/lib/esm/mcp/mcp-module.js

@@ -0,0 +1,31 @@
+import { PACKAGE_NAME as PKG, VERSION as V } from "../metadata";
+import { buildDocPrompts, buildPrompts, buildDocumentationPayload, discoverDocPrompts, loadPrompts, promptList, refreshPrompts, selectPrompt, DEFAULT_PROMPT_NAME, } from "./prompts";
+import { resources } from "./resources";
+import { buildDecorationResourceTemplates, buildResourceTemplates, decorationResourceTemplates, templateList, workspaceResourceTemplates, } from "./templates";
+import { toolList, tools } from "./tools";
+import { __resetWorkspaceRoot, getWorkspaceRoot, setWorkspaceRoot, } from "./workspace";
+export function enrich(mcp) {
+    const promptEntries = loadPrompts();
+    for (const prompt of promptEntries) {
+        mcp.addPrompt(prompt);
+    }
+    for (const tool of toolList) {
+        mcp.addTool(tool);
+    }
+    const templates = buildResourceTemplates();
+    for (const template of templates) {
+        mcp.addResourceTemplate(template);
+    }
+    for (const resource of resources) {
+        const addResource = mcp.addResource;
+        if (typeof addResource === "function") {
+            addResource.call(mcp, resource);
+        }
+    }
+    return mcp;
+}
+export default enrich;
+export const PACKAGE_NAME = PKG;
+export const VERSION = V;
+export { tools, toolList, buildDocPrompts, buildPrompts, buildDecorationResourceTemplates, buildResourceTemplates, buildDocumentationPayload, decorationResourceTemplates, discoverDocPrompts, DEFAULT_PROMPT_NAME, promptList, refreshPrompts, resources, selectPrompt, templateList, workspaceResourceTemplates, getWorkspaceRoot, setWorkspaceRoot, __resetWorkspaceRoot, };
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,12 @@
+import type { ModuleExportPackage, PromptAsset, ResourceAsset, TemplateAsset, ToolAsset } from "../types";
+export declare class ModuleRegistry {
+    private readonly packages;
+    constructor(packages?: ModuleExportPackage[]);
+    listPackages(): ModuleExportPackage[];
+    listPrompts(): PromptAsset[];
+    listResources(): ResourceAsset[];
+    listTemplates(): TemplateAsset[];
+    listTools(): ToolAsset[];
+    private collectAssets;
+}
+export declare const moduleRegistry: ModuleRegistry;

package/lib/esm/mcp/moduleRegistry.js

@@ -0,0 +1,46 @@
+import { modulePackages } from "../modules";
+export class ModuleRegistry {
+    // Defensive default: modulePackages may be undefined during circular imports
+    constructor(packages = Array.isArray(modulePackages)
+        ? modulePackages
+        : []) {
+        this.packages = packages;
+    }
+    listPackages() {
+        return this.packages;
+    }
+    listPrompts() {
+        return this.collectAssets("prompts");
+    }
+    listResources() {
+        return this.collectAssets("resources");
+    }
+    listTemplates() {
+        return this.collectAssets("templates");
+    }
+    listTools() {
+        return this.collectAssets("tools");
+    }
+    collectAssets(key) {
+        const seen = new Map();
+        const aggregated = [];
+        for (const pkg of this.packages) {
+            if (pkg.status === "disabled")
+                continue;
+            for (const asset of pkg[key]) {
+                // asset.name is not guaranteed on all asset types; use type-safe fallback
+                const maybeName = asset.name;
+                const assetKey = (asset && (asset.id ?? maybeName)) || JSON.stringify(asset);
+                if (seen.has(assetKey)) {
+                    const conflict = seen.get(assetKey);
+                    throw new Error(`Duplicate ${key} id '${assetKey}' from modules ${conflict} and ${pkg.name}`);
+                }
+                seen.set(assetKey, pkg.name);
+                aggregated.push({ ...asset, provenance: pkg.name });
+            }
+        }
+        return aggregated;
+    }
+}
+export const moduleRegistry = new ModuleRegistry();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,4 @@
+import type { InputPrompt } from "fastmcp";
+export * from "./prompts";
+export declare const promptList: InputPrompt<undefined>[];
+export declare function loadPrompts(repoPath?: string): InputPrompt<undefined>[];

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

@@ -0,0 +1,7 @@
+import { prompts, refreshPrompts } from "./prompts";
+export * from "./prompts";
+export const promptList = prompts;
+export function loadPrompts(repoPath) {
+    return refreshPrompts(repoPath);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbWNwL3Byb21wdHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxXQUFXLENBQUM7QUFFcEQsY0FBYyxXQUFXLENBQUM7QUFFMUIsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUE2QixPQUFPLENBQUM7QUFFNUQsTUFBTSxVQUFVLFdBQVcsQ0FBQyxRQUFpQjtJQUMzQyxPQUFPLGNBQWMsQ0FBQyxRQUFRLENBQUMsQ0FBQztBQUNsQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBJbnB1dFByb21wdCB9IGZyb20gXCJmYXN0bWNwXCI7XG5pbXBvcnQgeyBwcm9tcHRzLCByZWZyZXNoUHJvbXB0cyB9IGZyb20gXCIuL3Byb21wdHNcIjtcblxuZXhwb3J0ICogZnJvbSBcIi4vcHJvbXB0c1wiO1xuXG5leHBvcnQgY29uc3QgcHJvbXB0TGlzdDogSW5wdXRQcm9tcHQ8dW5kZWZpbmVkPltdID0gcHJvbXB0cztcblxuZXhwb3J0IGZ1bmN0aW9uIGxvYWRQcm9tcHRzKHJlcG9QYXRoPzogc3RyaW5nKTogSW5wdXRQcm9tcHQ8dW5kZWZpbmVkPltdIHtcbiAgcmV0dXJuIHJlZnJlc2hQcm9tcHRzKHJlcG9QYXRoKTtcbn1cbiJdfQ==

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

@@ -0,0 +1,22 @@
+import type { ContentResult, InputPrompt } from "fastmcp";
+import { DEFAULT_PROMPT_NAME } from "../../constants";
+import type { DocPrompt } from "../types";
+export declare const prompts: InputPrompt<undefined>[];
+export declare function getObjectPromptDependencies(): Record<string, readonly string[]>;
+export declare function buildPrompts(repoPath: string): InputPrompt<undefined>[];
+export declare function buildDocPrompts(): InputPrompt<undefined>[];
+export declare function buildObjectPrompts(): InputPrompt<undefined>[];
+export declare function refreshPrompts(repoPath?: string): InputPrompt<undefined>[];
+export declare function discoverDocPrompts(root: string): DocPrompt[];
+export declare function selectPrompt(promptList: DocPrompt[], requestedName: string): DocPrompt;
+export declare function buildDocumentationPayload({ filePath, fileContent, prompt, includePrompt, includeCode, includeMetadata, additionalContext, }: {
+    filePath: string;
+    fileContent: string;
+    prompt: DocPrompt;
+    includePrompt: boolean;
+    includeCode: boolean;
+    includeMetadata: boolean;
+    additionalContext?: string;
+}): ContentResult;
+export { DEFAULT_PROMPT_NAME };
+export type { DocPrompt };

package/lib/esm/mcp/prompts/prompts.js

@@ -0,0 +1,197 @@
+import fs from "fs";
+import path from "path";
+import { CLIENT_INTEGRATIONS, DEFAULT_PROMPT_NAME, PROMPT_DIRECTORIES, } from "../../constants";
+import { getWorkspaceRoot } from "../workspace";
+import { moduleRegistry } from "../moduleRegistry";
+export const prompts = [];
+const OBJECT_PROMPT_DEPENDENCIES = {
+    module: ["doc", "module"],
+    file: ["doc", "file"],
+    class: ["doc", "class"],
+    function: ["doc", "function"],
+    interface: ["doc", "interface"],
+    decorator: ["doc", "decorator"],
+    constant: ["doc", "constant"],
+    "bulk-docs": ["bulk-docs"],
+    "bulk-tests": ["bulk-tests"],
+    "update-readme": ["update-readme"],
+    "repo-setup": ["repo-setup"],
+    "release-notes": ["release-notes"],
+    "mcp-module": ["mcp-module"],
+};
+export function getObjectPromptDependencies() {
+    return OBJECT_PROMPT_DEPENDENCIES;
+}
+export 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.`,
+        },
+    ];
+}
+export function buildDocPrompts() {
+    const root = getWorkspaceRoot();
+    const fileBasedPrompts = discoverDocPrompts(root).map((prompt) => ({
+        name: `doc/${prompt.name}`,
+        description: prompt.description,
+        load: async () => prompt.content,
+    }));
+    const integrationPrompts = CLIENT_INTEGRATIONS.map((integration) => ({
+        name: `integration/${integration.id}`,
+        description: `${integration.display} integration guidance`,
+        load: async () => `You are coordinating with ${integration.display}. ${integration.instructions}\n\nTools available:\n- document-code\n- apply-code-change\n\nEnsure responses include actionable steps for the client.`,
+    }));
+    return [...fileBasedPrompts, ...integrationPrompts];
+}
+function summarizePromptContent(prompt, headingPrefix) {
+    return [`## ${headingPrefix}`, "", prompt.content.trim()].join("\n");
+}
+export function buildObjectPrompts() {
+    const root = getWorkspaceRoot();
+    const discovered = discoverDocPrompts(root);
+    const promptByName = new Map();
+    for (const prompt of discovered) {
+        promptByName.set(prompt.name, prompt);
+    }
+    const outputs = [];
+    for (const [objectType, dependencies] of Object.entries(OBJECT_PROMPT_DEPENDENCIES)) {
+        const existing = dependencies
+            .map((name) => promptByName.get(name))
+            .filter((prompt) => Boolean(prompt));
+        if (!existing.length)
+            continue;
+        outputs.push({
+            name: `codex/${objectType}`,
+            description: `Guidance derived from .codex prompts for ${objectType} tasks.`,
+            load: async () => {
+                const sections = existing.map((prompt) => summarizePromptContent(prompt, toTitleCase(prompt.name)));
+                return [`# Codex guidance for ${objectType}`, "", ...sections].join("\n");
+            },
+        });
+    }
+    return outputs.sort((a, b) => a.name.localeCompare(b.name));
+}
+function toInputPrompt(asset) {
+    const provenance = asset.provenance ? ` (module: ${asset.provenance})` : "";
+    return {
+        name: asset.id,
+        description: `${asset.description ?? asset.title}${provenance}`,
+        load: async () => asset.load(),
+    };
+}
+function buildModulePrompts() {
+    return moduleRegistry.listPrompts().map(toInputPrompt);
+}
+export function refreshPrompts(repoPath) {
+    const docPrompts = buildDocPrompts();
+    const objectPrompts = buildObjectPrompts();
+    const repoPrompts = repoPath ? buildPrompts(repoPath) : [];
+    const modulePrompts = buildModulePrompts();
+    prompts.splice(0, prompts.length, ...docPrompts, ...objectPrompts, ...repoPrompts, ...modulePrompts);
+    return prompts;
+}
+export function discoverDocPrompts(root) {
+    const discovered = [];
+    for (const directory of PROMPT_DIRECTORIES) {
+        const promptDir = path.join(root, directory);
+        // debug logging to help tests diagnose prompt discovery
+        console.debug("[discoverDocPrompts] checking", promptDir);
+        if (!fs.existsSync(promptDir) || !fs.statSync(promptDir).isDirectory()) {
+            continue;
+        }
+        for (const entry of fs.readdirSync(promptDir)) {
+            const fullPath = path.join(promptDir, entry);
+            if (!fs.statSync(fullPath).isFile())
+                continue;
+            const name = path.parse(entry).name;
+            const content = fs.readFileSync(fullPath, "utf8");
+            const title = toTitleCase(name.replace(/[-_]/g, " "));
+            const description = extractDescription(content, fullPath);
+            discovered.push({
+                name,
+                title,
+                description,
+                content,
+                absolutePath: fullPath,
+            });
+        }
+    }
+    const unique = new Map();
+    for (const prompt of discovered) {
+        if (!unique.has(prompt.name)) {
+            unique.set(prompt.name, prompt);
+        }
+    }
+    return Array.from(unique.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+export function selectPrompt(promptList, requestedName) {
+    const direct = promptList.find((prompt) => prompt.name === requestedName);
+    if (direct)
+        return direct;
+    const fallback = promptList.find((prompt) => prompt.name === DEFAULT_PROMPT_NAME);
+    if (fallback)
+        return fallback;
+    if (!promptList.length) {
+        throw new Error("No documentation prompts available");
+    }
+    return promptList[0];
+}
+export function buildDocumentationPayload({ filePath, fileContent, prompt, includePrompt, includeCode, includeMetadata, additionalContext, }) {
+    const sections = [];
+    if (includeMetadata) {
+        sections.push(`# Documentation Request\n- prompt: ${prompt.name}\n- file: ${filePath}`);
+    }
+    if (includePrompt) {
+        sections.push(`## Prompt Guidance (${prompt.title})\n\n${prompt.content.trim()}`);
+    }
+    if (additionalContext?.trim()) {
+        sections.push(`## Additional Context\n\n${additionalContext.trim()}`);
+    }
+    if (includeCode) {
+        sections.push(`## Source\n\n\`\`\`${inferLanguageFromPath(filePath)}\n${fileContent}\n\`\`\``);
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: sections.join("\n\n"),
+            },
+        ],
+    };
+}
+function extractDescription(content, filePath) {
+    const firstLine = content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    return (firstLine?.slice(0, 240) ??
+        `Documentation prompt loaded from ${path.basename(filePath)}`);
+}
+function toTitleCase(value) {
+    return value
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+        .join(" ");
+}
+function inferLanguageFromPath(filePath) {
+    const extension = path.extname(filePath).toLowerCase();
+    switch (extension) {
+        case ".ts":
+        case ".tsx":
+            return "ts";
+        case ".js":
+        case ".jsx":
+            return "js";
+        case ".json":
+            return "json";
+        case ".md":
+            return "md";
+        default:
+            return "text";
+    }
+}
+export { DEFAULT_PROMPT_NAME };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prompts.js","sourceRoot":"","sources":["../../../../src/mcp/prompts/prompts.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\nimport type { ContentResult, InputPrompt } from \"fastmcp\";\nimport {\n  CLIENT_INTEGRATIONS,\n  DEFAULT_PROMPT_NAME,\n  PROMPT_DIRECTORIES,\n} from \"../../constants\";\nimport type { DocPrompt } from \"../types\";\nimport { getWorkspaceRoot } from \"../workspace\";\nimport type { PromptAsset } from \"../../types\";\nimport { moduleRegistry } from \"../moduleRegistry\";\n\nexport const prompts: InputPrompt<undefined>[] = [];\n\nconst OBJECT_PROMPT_DEPENDENCIES: Record<string, readonly string[]> = {\n  module: [\"doc\", \"module\"],\n  file: [\"doc\", \"file\"],\n  class: [\"doc\", \"class\"],\n  function: [\"doc\", \"function\"],\n  interface: [\"doc\", \"interface\"],\n  decorator: [\"doc\", \"decorator\"],\n  constant: [\"doc\", \"constant\"],\n  \"bulk-docs\": [\"bulk-docs\"],\n  \"bulk-tests\": [\"bulk-tests\"],\n  \"update-readme\": [\"update-readme\"],\n  \"repo-setup\": [\"repo-setup\"],\n  \"release-notes\": [\"release-notes\"],\n  \"mcp-module\": [\"mcp-module\"],\n};\n\nexport function getObjectPromptDependencies(): Record<\n  string,\n  readonly string[]\n> {\n  return OBJECT_PROMPT_DEPENDENCIES;\n}\n\nexport function 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\nexport function buildDocPrompts(): InputPrompt<undefined>[] {\n  const root = getWorkspaceRoot();\n  const fileBasedPrompts = discoverDocPrompts(root).map((prompt) => ({\n    name: `doc/${prompt.name}`,\n    description: prompt.description,\n    load: async () => prompt.content,\n  }));\n\n  const integrationPrompts = CLIENT_INTEGRATIONS.map<InputPrompt<undefined>>(\n    (integration) => ({\n      name: `integration/${integration.id}`,\n      description: `${integration.display} integration guidance`,\n      load: async () =>\n        `You are coordinating with ${integration.display}. ${integration.instructions}\\n\\nTools available:\\n- document-code\\n- apply-code-change\\n\\nEnsure responses include actionable steps for the client.`,\n    })\n  );\n\n  return [...fileBasedPrompts, ...integrationPrompts];\n}\n\nfunction summarizePromptContent(\n  prompt: DocPrompt,\n  headingPrefix: string\n): string {\n  return [`## ${headingPrefix}`, \"\", prompt.content.trim()].join(\"\\n\");\n}\n\nexport function buildObjectPrompts(): InputPrompt<undefined>[] {\n  const root = getWorkspaceRoot();\n  const discovered = discoverDocPrompts(root);\n  const promptByName = new Map<string, DocPrompt>();\n  for (const prompt of discovered) {\n    promptByName.set(prompt.name, prompt);\n  }\n\n  const outputs: InputPrompt<undefined>[] = [];\n  for (const [objectType, dependencies] of Object.entries(\n    OBJECT_PROMPT_DEPENDENCIES\n  )) {\n    const existing = dependencies\n      .map((name) => promptByName.get(name))\n      .filter((prompt): prompt is DocPrompt => Boolean(prompt));\n    if (!existing.length) continue;\n\n    outputs.push({\n      name: `codex/${objectType}`,\n      description: `Guidance derived from .codex prompts for ${objectType} tasks.`,\n      load: async () => {\n        const sections = existing.map((prompt) =>\n          summarizePromptContent(prompt, toTitleCase(prompt.name))\n        );\n        return [`# Codex guidance for ${objectType}`, \"\", ...sections].join(\n          \"\\n\"\n        );\n      },\n    });\n  }\n\n  return outputs.sort((a, b) => a.name.localeCompare(b.name));\n}\n\nfunction toInputPrompt(asset: PromptAsset): InputPrompt<undefined> {\n  const provenance = asset.provenance ? ` (module: ${asset.provenance})` : \"\";\n  return {\n    name: asset.id,\n    description: `${asset.description ?? asset.title}${provenance}`,\n    load: async () => asset.load(),\n  };\n}\n\nfunction buildModulePrompts(): InputPrompt<undefined>[] {\n  return moduleRegistry.listPrompts().map(toInputPrompt);\n}\n\nexport function refreshPrompts(repoPath?: string): InputPrompt<undefined>[] {\n  const docPrompts = buildDocPrompts();\n  const objectPrompts = buildObjectPrompts();\n  const repoPrompts = repoPath ? buildPrompts(repoPath) : [];\n  const modulePrompts = buildModulePrompts();\n  prompts.splice(\n    0,\n    prompts.length,\n    ...docPrompts,\n    ...objectPrompts,\n    ...repoPrompts,\n    ...modulePrompts\n  );\n  return prompts;\n}\n\nexport function discoverDocPrompts(root: string): DocPrompt[] {\n  const discovered: DocPrompt[] = [];\n\n  for (const directory of PROMPT_DIRECTORIES) {\n    const promptDir = path.join(root, directory);\n    // debug logging to help tests diagnose prompt discovery\n\n    console.debug(\"[discoverDocPrompts] checking\", promptDir);\n    if (!fs.existsSync(promptDir) || !fs.statSync(promptDir).isDirectory()) {\n      continue;\n    }\n\n    for (const entry of fs.readdirSync(promptDir)) {\n      const fullPath = path.join(promptDir, entry);\n      if (!fs.statSync(fullPath).isFile()) continue;\n\n      const name = path.parse(entry).name;\n      const content = fs.readFileSync(fullPath, \"utf8\");\n      const title = toTitleCase(name.replace(/[-_]/g, \" \"));\n      const description = extractDescription(content, fullPath);\n\n      discovered.push({\n        name,\n        title,\n        description,\n        content,\n        absolutePath: fullPath,\n      });\n    }\n  }\n\n  const unique = new Map<string, DocPrompt>();\n  for (const prompt of discovered) {\n    if (!unique.has(prompt.name)) {\n      unique.set(prompt.name, prompt);\n    }\n  }\n\n  return Array.from(unique.values()).sort((a, b) =>\n    a.name.localeCompare(b.name)\n  );\n}\n\nexport function selectPrompt(\n  promptList: DocPrompt[],\n  requestedName: string\n): DocPrompt {\n  const direct = promptList.find((prompt) => prompt.name === requestedName);\n  if (direct) return direct;\n\n  const fallback = promptList.find(\n    (prompt) => prompt.name === DEFAULT_PROMPT_NAME\n  );\n  if (fallback) return fallback;\n\n  if (!promptList.length) {\n    throw new Error(\"No documentation prompts available\");\n  }\n\n  return promptList[0];\n}\n\nexport function buildDocumentationPayload({\n  filePath,\n  fileContent,\n  prompt,\n  includePrompt,\n  includeCode,\n  includeMetadata,\n  additionalContext,\n}: {\n  filePath: string;\n  fileContent: string;\n  prompt: DocPrompt;\n  includePrompt: boolean;\n  includeCode: boolean;\n  includeMetadata: boolean;\n  additionalContext?: string;\n}): ContentResult {\n  const sections: string[] = [];\n\n  if (includeMetadata) {\n    sections.push(\n      `# Documentation Request\\n- prompt: ${prompt.name}\\n- file: ${filePath}`\n    );\n  }\n\n  if (includePrompt) {\n    sections.push(\n      `## Prompt Guidance (${prompt.title})\\n\\n${prompt.content.trim()}`\n    );\n  }\n\n  if (additionalContext?.trim()) {\n    sections.push(`## Additional Context\\n\\n${additionalContext.trim()}`);\n  }\n\n  if (includeCode) {\n    sections.push(\n      `## Source\\n\\n\\`\\`\\`${inferLanguageFromPath(filePath)}\\n${fileContent}\\n\\`\\`\\``\n    );\n  }\n\n  return {\n    content: [\n      {\n        type: \"text\",\n        text: sections.join(\"\\n\\n\"),\n      },\n    ],\n  } satisfies ContentResult;\n}\n\nfunction extractDescription(content: string, filePath: string): string {\n  const firstLine = content\n    .split(/\\r?\\n/)\n    .map((line) => line.trim())\n    .find((line) => line.length > 0);\n\n  return (\n    firstLine?.slice(0, 240) ??\n    `Documentation prompt loaded from ${path.basename(filePath)}`\n  );\n}\n\nfunction toTitleCase(value: string): string {\n  return value\n    .split(/\\s+/)\n    .filter(Boolean)\n    .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())\n    .join(\" \");\n}\n\nfunction inferLanguageFromPath(filePath: string): string {\n  const extension = path.extname(filePath).toLowerCase();\n  switch (extension) {\n    case \".ts\":\n    case \".tsx\":\n      return \"ts\";\n    case \".js\":\n    case \".jsx\":\n      return \"js\";\n    case \".json\":\n      return \"json\";\n    case \".md\":\n      return \"md\";\n    default:\n      return \"text\";\n  }\n}\n\nexport { DEFAULT_PROMPT_NAME };\nexport type { DocPrompt };\n"]}

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

@@ -0,0 +1 @@
+export * from "./resources";

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

@@ -0,0 +1,2 @@
+export * from "./resources";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbWNwL3Jlc291cmNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL3Jlc291cmNlc1wiO1xuIl19

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

@@ -0,0 +1,2 @@
+import type { Resource } from "fastmcp";
+export declare const resources: Resource<undefined>[];

package/lib/esm/mcp/resources/resources.js

@@ -0,0 +1,69 @@
+import { moduleRegistry } from "../moduleRegistry";
+import { getWorkspaceRoot } from "../workspace";
+import { buildObjectPrompts, discoverDocPrompts } from "../prompts/prompts";
+function toResource(asset) {
+    return {
+        name: asset.id,
+        uri: asset.uri,
+        description: asset.description ?? asset.title,
+        mimeType: asset.mimeType,
+        load: async () => {
+            const res = await asset.load();
+            // asset.load may return a ContentResult or a Promise of ContentResult; ensure we return ResourceResult-like object
+            if (res?.content) {
+                const cr = res;
+                // If ContentResult, convert to simple text result expected by Resource.load consumers
+                return {
+                    text: Array.isArray(cr.content)
+                        ? cr.content.map((c) => c.text).join("\n")
+                        : String(cr),
+                };
+            }
+            // fallback for objects with text
+            return res;
+        },
+    };
+}
+function buildModuleResources() {
+    return moduleRegistry.listResources().map(toResource);
+}
+export const resources = [
+    {
+        name: "codex-prompt-index",
+        uri: "codex://prompts/index",
+        description: "Enumerate available .codex prompt files with titles and descriptions.",
+        mimeType: "application/json",
+        load: async () => {
+            const root = getWorkspaceRoot();
+            const prompts = discoverDocPrompts(root).map((prompt) => ({
+                name: prompt.name,
+                title: prompt.title,
+                description: prompt.description,
+                path: prompt.absolutePath,
+            }));
+            return {
+                text: JSON.stringify({ prompts }, null, 2),
+                mimeType: "application/json",
+            };
+        },
+    },
+    {
+        name: "codex-object-prompts",
+        uri: "codex://prompts/objects",
+        description: "Provides the resolved prompt content for each documented object workflow.",
+        mimeType: "application/json",
+        load: async () => {
+            const entries = await Promise.all(buildObjectPrompts().map(async (prompt) => ({
+                name: prompt.name,
+                description: prompt.description,
+                content: await prompt.load({}),
+            })));
+            return {
+                text: JSON.stringify({ prompts: entries }, null, 2),
+                mimeType: "application/json",
+            };
+        },
+    },
+    ...buildModuleResources(),
+];
+//# sourceMappingURL=data:application/json;base64,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