@decaf-ts/mcp-server 0.0.3 → 0.2.0

package/lib/mcp/templates/index.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateList = exports.workspaceResourceTemplates = exports.buildWorkspaceResourceTemplates = exports.decorationResourceTemplates = exports.buildDecorationResourceTemplates = exports.codexPromptTemplates = exports.buildCodexPromptTemplates = void 0;
+exports.buildResourceTemplates = buildResourceTemplates;
+const codex_templates_1 = require("./codex-templates.cjs");
+const resource_templates_1 = require("./resource-templates.cjs");
+const workspace_templates_1 = require("./workspace-templates.cjs");
+const moduleRegistry_1 = require("./../moduleRegistry.cjs");
+var codex_templates_2 = require("./codex-templates.cjs");
+Object.defineProperty(exports, "buildCodexPromptTemplates", { enumerable: true, get: function () { return codex_templates_2.buildCodexPromptTemplates; } });
+Object.defineProperty(exports, "codexPromptTemplates", { enumerable: true, get: function () { return codex_templates_2.codexPromptTemplates; } });
+var resource_templates_2 = require("./resource-templates.cjs");
+Object.defineProperty(exports, "buildDecorationResourceTemplates", { enumerable: true, get: function () { return resource_templates_2.buildDecorationResourceTemplates; } });
+Object.defineProperty(exports, "decorationResourceTemplates", { enumerable: true, get: function () { return resource_templates_2.decorationResourceTemplates; } });
+var workspace_templates_2 = require("./workspace-templates.cjs");
+Object.defineProperty(exports, "buildWorkspaceResourceTemplates", { enumerable: true, get: function () { return workspace_templates_2.buildWorkspaceResourceTemplates; } });
+Object.defineProperty(exports, "workspaceResourceTemplates", { enumerable: true, get: function () { return workspace_templates_2.workspaceResourceTemplates; } });
+function buildResourceTemplates() {
+    const moduleTemplates = moduleRegistry_1.moduleRegistry.listTemplates().map((template) => ({
+        name: template.id,
+        description: template.description ?? template.title,
+        mimeType: "text/markdown",
+        uriTemplate: `module-template://${template.id}`,
+        arguments: (template.placeholders ?? []).map((name) => ({
+            name,
+            description: `Value for ${name}`,
+            required: true,
+        })),
+        load: async () => ({
+            text: typeof template.content === "string"
+                ? template.content
+                : `# ${template.description ?? template.title ?? template.id}\n\nNo template content available for ${template.id}`,
+        }),
+    }));
+    const all = [
+        ...(0, workspace_templates_1.buildWorkspaceResourceTemplates)(),
+        ...(0, codex_templates_1.buildCodexPromptTemplates)(),
+        ...(0, resource_templates_1.buildDecorationResourceTemplates)(),
+        ...moduleTemplates,
+    ];
+    // Normalise all loaders to always return { text: string }
+    function normaliseResult(res) {
+        if (res == null)
+            return { text: "" };
+        if (typeof res === "string")
+            return { text: res };
+        if (typeof res.text === "string")
+            return res;
+        // handle legacy ContentResult shapes with content or content array
+        if (Array.isArray(res.content)) {
+            const parts = res.content
+                .map((c) => (c && typeof c.text === "string" ? c.text : String(c)))
+                .join("\n");
+            return { text: parts };
+        }
+        if (res.content && typeof res.content.text === "string") {
+            return { text: res.content.text };
+        }
+        // fallback: stringify
+        try {
+            return { text: JSON.stringify(res) };
+        }
+        catch {
+            return { text: String(res) };
+        }
+    }
+    return all.map((t) => ({
+        ...t,
+        load: async (args) => {
+            const raw = await t.load(args);
+            return normaliseResult(raw);
+        },
+    }));
+}
+exports.templateList = buildResourceTemplates();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWNwL3RlbXBsYXRlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUE0QkEsd0RBd0RDO0FBcEZELDJEQUcyQjtBQUMzQixpRUFHOEI7QUFDOUIsbUVBRytCO0FBRS9CLDREQUFtRDtBQUVuRCx5REFHMkI7QUFGekIsNEhBQUEseUJBQXlCLE9BQUE7QUFDekIsdUhBQUEsb0JBQW9CLE9BQUE7QUFFdEIsK0RBRzhCO0FBRjVCLHNJQUFBLGdDQUFnQyxPQUFBO0FBQ2hDLGlJQUFBLDJCQUEyQixPQUFBO0FBRTdCLGlFQUcrQjtBQUY3QixzSUFBQSwrQkFBK0IsT0FBQTtBQUMvQixpSUFBQSwwQkFBMEIsT0FBQTtBQUc1QixTQUFnQixzQkFBc0I7SUFDcEMsTUFBTSxlQUFlLEdBQUcsK0JBQWMsQ0FBQyxhQUFhLEVBQUUsQ0FBQyxHQUFHLENBQUMsQ0FBQyxRQUFRLEVBQUUsRUFBRSxDQUFDLENBQUM7UUFDeEUsSUFBSSxFQUFFLFFBQVEsQ0FBQyxFQUFFO1FBQ2pCLFdBQVcsRUFBRSxRQUFRLENBQUMsV0FBVyxJQUFJLFFBQVEsQ0FBQyxLQUFLO1FBQ25ELFFBQVEsRUFBRSxlQUFlO1FBQ3pCLFdBQVcsRUFBRSxxQkFBcUIsUUFBUSxDQUFDLEVBQUUsRUFBRTtRQUMvQyxTQUFTLEVBQUUsQ0FBQyxRQUFRLENBQUMsWUFBWSxJQUFJLEVBQUUsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsQ0FBQztZQUN0RCxJQUFJO1lBQ0osV0FBVyxFQUFFLGFBQWEsSUFBSSxFQUFFO1lBQ2hDLFFBQVEsRUFBRSxJQUFJO1NBQ2YsQ0FBQyxDQUFDO1FBQ0gsSUFBSSxFQUFFLEtBQUssSUFBSSxFQUFFLENBQUMsQ0FBQztZQUNqQixJQUFJLEVBQ0YsT0FBUSxRQUFnQixDQUFDLE9BQU8sS0FBSyxRQUFRO2dCQUMzQyxDQUFDLENBQUUsUUFBZ0IsQ0FBQyxPQUFPO2dCQUMzQixDQUFDLENBQUMsS0FBSyxRQUFRLENBQUMsV0FBVyxJQUFJLFFBQVEsQ0FBQyxLQUFLLElBQUksUUFBUSxDQUFDLEVBQUUseUNBQXlDLFFBQVEsQ0FBQyxFQUFFLEVBQUU7U0FDdkgsQ0FBQztLQUNILENBQUMsQ0FBQyxDQUFDO0lBRUosTUFBTSxHQUFHLEdBQUc7UUFDVixHQUFHLElBQUEscURBQStCLEdBQUU7UUFDcEMsR0FBRyxJQUFBLDJDQUF5QixHQUFFO1FBQzlCLEdBQUcsSUFBQSxxREFBZ0MsR0FBRTtRQUNyQyxHQUFHLGVBQWU7S0FDbkIsQ0FBQztJQUVGLDBEQUEwRDtJQUMxRCxTQUFTLGVBQWUsQ0FBQyxHQUFRO1FBQy9CLElBQUksR0FBRyxJQUFJLElBQUk7WUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLEVBQUUsRUFBRSxDQUFDO1FBQ3JDLElBQUksT0FBTyxHQUFHLEtBQUssUUFBUTtZQUFFLE9BQU8sRUFBRSxJQUFJLEVBQUUsR0FBRyxFQUFFLENBQUM7UUFDbEQsSUFBSSxPQUFPLEdBQUcsQ0FBQyxJQUFJLEtBQUssUUFBUTtZQUFFLE9BQU8sR0FBRyxDQUFDO1FBQzdDLG1FQUFtRTtRQUNuRSxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7WUFDL0IsTUFBTSxLQUFLLEdBQUcsR0FBRyxDQUFDLE9BQU87aUJBQ3RCLEdBQUcsQ0FBQyxDQUFDLENBQU0sRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLElBQUksT0FBTyxDQUFDLENBQUMsSUFBSSxLQUFLLFFBQVEsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUM7aUJBQ3ZFLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztZQUNkLE9BQU8sRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLENBQUM7UUFDekIsQ0FBQztRQUNELElBQUksR0FBRyxDQUFDLE9BQU8sSUFBSSxPQUFPLEdBQUcsQ0FBQyxPQUFPLENBQUMsSUFBSSxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBQ3hELE9BQU8sRUFBRSxJQUFJLEVBQUUsR0FBRyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUNwQyxDQUFDO1FBQ0Qsc0JBQXNCO1FBQ3RCLElBQUksQ0FBQztZQUNILE9BQU8sRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ3ZDLENBQUM7UUFBQyxNQUFNLENBQUM7WUFDUCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQy9CLENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1FBQ3JCLEdBQUcsQ0FBQztRQUNKLElBQUksRUFBRSxLQUFLLEVBQUUsSUFBUyxFQUFFLEVBQUU7WUFDeEIsTUFBTSxHQUFHLEdBQUcsTUFBTyxDQUFDLENBQUMsSUFBWSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQ3hDLE9BQU8sZUFBZSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1FBQzlCLENBQUM7S0FDRixDQUFDLENBQUMsQ0FBQztBQUNOLENBQUM7QUFFWSxRQUFBLFlBQVksR0FBRyxzQkFBc0IsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgYnVpbGRDb2RleFByb21wdFRlbXBsYXRlcyxcbiAgY29kZXhQcm9tcHRUZW1wbGF0ZXMsXG59IGZyb20gXCIuL2NvZGV4LXRlbXBsYXRlc1wiO1xuaW1wb3J0IHtcbiAgYnVpbGREZWNvcmF0aW9uUmVzb3VyY2VUZW1wbGF0ZXMsXG4gIGRlY29yYXRpb25SZXNvdXJjZVRlbXBsYXRlcyxcbn0gZnJvbSBcIi4vcmVzb3VyY2UtdGVtcGxhdGVzXCI7XG5pbXBvcnQge1xuICBidWlsZFdvcmtzcGFjZVJlc291cmNlVGVtcGxhdGVzLFxuICB3b3Jrc3BhY2VSZXNvdXJjZVRlbXBsYXRlcyxcbn0gZnJvbSBcIi4vd29ya3NwYWNlLXRlbXBsYXRlc1wiO1xuaW1wb3J0IHR5cGUgeyBUZW1wbGF0ZUFzc2V0IH0gZnJvbSBcIi4uLy4uL3R5cGVzXCI7XG5pbXBvcnQgeyBtb2R1bGVSZWdpc3RyeSB9IGZyb20gXCIuLi9tb2R1bGVSZWdpc3RyeVwiO1xuXG5leHBvcnQge1xuICBidWlsZENvZGV4UHJvbXB0VGVtcGxhdGVzLFxuICBjb2RleFByb21wdFRlbXBsYXRlcyxcbn0gZnJvbSBcIi4vY29kZXgtdGVtcGxhdGVzXCI7XG5leHBvcnQge1xuICBidWlsZERlY29yYXRpb25SZXNvdXJjZVRlbXBsYXRlcyxcbiAgZGVjb3JhdGlvblJlc291cmNlVGVtcGxhdGVzLFxufSBmcm9tIFwiLi9yZXNvdXJjZS10ZW1wbGF0ZXNcIjtcbmV4cG9ydCB7XG4gIGJ1aWxkV29ya3NwYWNlUmVzb3VyY2VUZW1wbGF0ZXMsXG4gIHdvcmtzcGFjZVJlc291cmNlVGVtcGxhdGVzLFxufSBmcm9tIFwiLi93b3Jrc3BhY2UtdGVtcGxhdGVzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBidWlsZFJlc291cmNlVGVtcGxhdGVzKCkge1xuICBjb25zdCBtb2R1bGVUZW1wbGF0ZXMgPSBtb2R1bGVSZWdpc3RyeS5saXN0VGVtcGxhdGVzKCkubWFwKCh0ZW1wbGF0ZSkgPT4gKHtcbiAgICBuYW1lOiB0ZW1wbGF0ZS5pZCxcbiAgICBkZXNjcmlwdGlvbjogdGVtcGxhdGUuZGVzY3JpcHRpb24gPz8gdGVtcGxhdGUudGl0bGUsXG4gICAgbWltZVR5cGU6IFwidGV4dC9tYXJrZG93blwiLFxuICAgIHVyaVRlbXBsYXRlOiBgbW9kdWxlLXRlbXBsYXRlOi8vJHt0ZW1wbGF0ZS5pZH1gLFxuICAgIGFyZ3VtZW50czogKHRlbXBsYXRlLnBsYWNlaG9sZGVycyA/PyBbXSkubWFwKChuYW1lKSA9PiAoe1xuICAgICAgbmFtZSxcbiAgICAgIGRlc2NyaXB0aW9uOiBgVmFsdWUgZm9yICR7bmFtZX1gLFxuICAgICAgcmVxdWlyZWQ6IHRydWUsXG4gICAgfSkpLFxuICAgIGxvYWQ6IGFzeW5jICgpID0+ICh7XG4gICAgICB0ZXh0OlxuICAgICAgICB0eXBlb2YgKHRlbXBsYXRlIGFzIGFueSkuY29udGVudCA9PT0gXCJzdHJpbmdcIlxuICAgICAgICAgID8gKHRlbXBsYXRlIGFzIGFueSkuY29udGVudFxuICAgICAgICAgIDogYCMgJHt0ZW1wbGF0ZS5kZXNjcmlwdGlvbiA/PyB0ZW1wbGF0ZS50aXRsZSA/PyB0ZW1wbGF0ZS5pZH1cXG5cXG5ObyB0ZW1wbGF0ZSBjb250ZW50IGF2YWlsYWJsZSBmb3IgJHt0ZW1wbGF0ZS5pZH1gLFxuICAgIH0pLFxuICB9KSk7XG5cbiAgY29uc3QgYWxsID0gW1xuICAgIC4uLmJ1aWxkV29ya3NwYWNlUmVzb3VyY2VUZW1wbGF0ZXMoKSxcbiAgICAuLi5idWlsZENvZGV4UHJvbXB0VGVtcGxhdGVzKCksXG4gICAgLi4uYnVpbGREZWNvcmF0aW9uUmVzb3VyY2VUZW1wbGF0ZXMoKSxcbiAgICAuLi5tb2R1bGVUZW1wbGF0ZXMsXG4gIF07XG5cbiAgLy8gTm9ybWFsaXNlIGFsbCBsb2FkZXJzIHRvIGFsd2F5cyByZXR1cm4geyB0ZXh0OiBzdHJpbmcgfVxuICBmdW5jdGlvbiBub3JtYWxpc2VSZXN1bHQocmVzOiBhbnkpIHtcbiAgICBpZiAocmVzID09IG51bGwpIHJldHVybiB7IHRleHQ6IFwiXCIgfTtcbiAgICBpZiAodHlwZW9mIHJlcyA9PT0gXCJzdHJpbmdcIikgcmV0dXJuIHsgdGV4dDogcmVzIH07XG4gICAgaWYgKHR5cGVvZiByZXMudGV4dCA9PT0gXCJzdHJpbmdcIikgcmV0dXJuIHJlcztcbiAgICAvLyBoYW5kbGUgbGVnYWN5IENvbnRlbnRSZXN1bHQgc2hhcGVzIHdpdGggY29udGVudCBvciBjb250ZW50IGFycmF5XG4gICAgaWYgKEFycmF5LmlzQXJyYXkocmVzLmNvbnRlbnQpKSB7XG4gICAgICBjb25zdCBwYXJ0cyA9IHJlcy5jb250ZW50XG4gICAgICAgIC5tYXAoKGM6IGFueSkgPT4gKGMgJiYgdHlwZW9mIGMudGV4dCA9PT0gXCJzdHJpbmdcIiA/IGMudGV4dCA6IFN0cmluZyhjKSkpXG4gICAgICAgIC5qb2luKFwiXFxuXCIpO1xuICAgICAgcmV0dXJuIHsgdGV4dDogcGFydHMgfTtcbiAgICB9XG4gICAgaWYgKHJlcy5jb250ZW50ICYmIHR5cGVvZiByZXMuY29udGVudC50ZXh0ID09PSBcInN0cmluZ1wiKSB7XG4gICAgICByZXR1cm4geyB0ZXh0OiByZXMuY29udGVudC50ZXh0IH07XG4gICAgfVxuICAgIC8vIGZhbGxiYWNrOiBzdHJpbmdpZnlcbiAgICB0cnkge1xuICAgICAgcmV0dXJuIHsgdGV4dDogSlNPTi5zdHJpbmdpZnkocmVzKSB9O1xuICAgIH0gY2F0Y2gge1xuICAgICAgcmV0dXJuIHsgdGV4dDogU3RyaW5nKHJlcykgfTtcbiAgICB9XG4gIH1cblxuICByZXR1cm4gYWxsLm1hcCgodCkgPT4gKHtcbiAgICAuLi50LFxuICAgIGxvYWQ6IGFzeW5jIChhcmdzOiBhbnkpID0+IHtcbiAgICAgIGNvbnN0IHJhdyA9IGF3YWl0ICh0LmxvYWQgYXMgYW55KShhcmdzKTtcbiAgICAgIHJldHVybiBub3JtYWxpc2VSZXN1bHQocmF3KTtcbiAgICB9LFxuICB9KSk7XG59XG5cbmV4cG9ydCBjb25zdCB0ZW1wbGF0ZUxpc3QgPSBidWlsZFJlc291cmNlVGVtcGxhdGVzKCk7XG4iXX0=

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

@@ -0,0 +1,71 @@
+export { buildCodexPromptTemplates, codexPromptTemplates, } from "./codex-templates";
+export { buildDecorationResourceTemplates, decorationResourceTemplates, } from "./resource-templates";
+export { buildWorkspaceResourceTemplates, workspaceResourceTemplates, } from "./workspace-templates";
+export declare function buildResourceTemplates(): ({
+    load: (args: any) => Promise<any>;
+    name: string;
+    description: string;
+    uriTemplate: string;
+    mimeType: string;
+    arguments: ReadonlyArray<{
+        name: string;
+        description: string;
+        required: boolean;
+    }>;
+} | {
+    load: (args: any) => Promise<any>;
+    name: string;
+    description: string;
+    uriTemplate: string;
+    mimeType: string;
+    arguments: ReadonlyArray<{
+        name: string;
+        description: string;
+        required: boolean;
+    }>;
+} | {
+    load: (args: any) => Promise<any>;
+    name: string;
+    description: string;
+    mimeType: string;
+    uriTemplate: string;
+    arguments: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+})[];
+export declare const templateList: ({
+    load: (args: any) => Promise<any>;
+    name: string;
+    description: string;
+    uriTemplate: string;
+    mimeType: string;
+    arguments: ReadonlyArray<{
+        name: string;
+        description: string;
+        required: boolean;
+    }>;
+} | {
+    load: (args: any) => Promise<any>;
+    name: string;
+    description: string;
+    uriTemplate: string;
+    mimeType: string;
+    arguments: ReadonlyArray<{
+        name: string;
+        description: string;
+        required: boolean;
+    }>;
+} | {
+    load: (args: any) => Promise<any>;
+    name: string;
+    description: string;
+    mimeType: string;
+    uriTemplate: string;
+    arguments: {
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+})[];

package/lib/mcp/templates/resource-templates.cjs

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorationResourceTemplates = void 0;
+exports.buildDecorationResourceTemplates = buildDecorationResourceTemplates;
+const path_1 = __importDefault(require("path"));
+const workspace_1 = require("./../workspace.cjs");
+exports.decorationResourceTemplates = [];
+function makeLoader(type) {
+    return async ({ path: relative }) => {
+        const root = (0, workspace_1.getWorkspaceRoot)();
+        const target = path_1.default.join(type, relative);
+        const text = await (0, workspace_1.readWorkspaceFile)(root, target);
+        return { text };
+    };
+}
+function buildDecorationResourceTemplates() {
+    const templates = [
+        {
+            name: "read-code-from-source",
+            description: "Read a file from the <base_path>/src tree by relative path.",
+            mimeType: "text/plain",
+            uriTemplate: "from-source://src/{path}",
+            arguments: [
+                {
+                    name: "path",
+                    description: "Path under <base_path>/src to load, e.g. 'decoration/types.ts'",
+                    required: true,
+                },
+            ],
+            load: makeLoader("src"),
+        },
+        {
+            name: "read-test-from-source",
+            description: "Read a file from the <base_path>/tests tree by relative path.",
+            mimeType: "text/plain",
+            uriTemplate: "from-source://tests/{path}",
+            arguments: [
+                {
+                    name: "path",
+                    description: "Path under <base_path>/tests to load, e.g. 'decoration/tests/types.test.ts'",
+                    required: true,
+                },
+            ],
+            load: makeLoader("tests"),
+        },
+        {
+            name: "read-doc-from-source",
+            description: "Read a file from the <base_path>/workdocs tree by relative path.",
+            mimeType: "text/plain",
+            uriTemplate: "from-source://workdocs/{path}",
+            arguments: [
+                {
+                    name: "path",
+                    description: "Path under <base_path>/workdocs to load, e.g. 'decoration/workdocs/tutorials/for-developers.md'",
+                    required: true,
+                },
+            ],
+            load: makeLoader("workdocs"),
+        },
+    ];
+    exports.decorationResourceTemplates.splice(0, exports.decorationResourceTemplates.length, ...templates);
+    return exports.decorationResourceTemplates;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp/templates/resource-templates.d.ts

@@ -0,0 +1,3 @@
+import type { DecorationResourceTemplate } from "../types";
+export declare const decorationResourceTemplates: DecorationResourceTemplate[];
+export declare function buildDecorationResourceTemplates(): DecorationResourceTemplate[];

package/lib/mcp/templates/workspace-templates.cjs

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceResourceTemplates = void 0;
+exports.buildWorkspaceResourceTemplates = buildWorkspaceResourceTemplates;
+const workspace_1 = require("./../workspace.cjs");
+exports.workspaceResourceTemplates = [];
+function buildWorkspaceResourceTemplates() {
+    const root = (0, workspace_1.getWorkspaceRoot)();
+    const sharedArguments = [
+        {
+            name: "path",
+            description: "Path relative to the workspace root",
+            required: true,
+        },
+    ];
+    const templates = [
+        {
+            name: "vscode-workspace-file",
+            description: "Expose workspace files to Visual Studio Code via vscode:// URIs",
+            uriTemplate: "vscode://workspace/{path}",
+            mimeType: "text/plain",
+            arguments: sharedArguments,
+            load: async (args) => {
+                try {
+                    const text = await (0, workspace_1.readWorkspaceFile)(root, args.path);
+                    return { text: String(text) };
+                }
+                catch (err) {
+                    // propagate as-is for tests to assert errors
+                    throw err;
+                }
+            },
+        },
+        {
+            name: "cursor-workspace-file",
+            description: "Expose workspace files to Cursor via cursor:// URIs",
+            uriTemplate: "cursor://workspace/{path}",
+            mimeType: "text/plain",
+            arguments: sharedArguments,
+            load: async (args) => {
+                try {
+                    const text = await (0, workspace_1.readWorkspaceFile)(root, args.path);
+                    return { text: String(text) };
+                }
+                catch (err) {
+                    throw err;
+                }
+            },
+        },
+        {
+            name: "copilot-workspace-file",
+            description: "Expose workspace files to GitHub Copilot via copilot:// URIs",
+            uriTemplate: "copilot://workspace/{path}",
+            mimeType: "text/plain",
+            arguments: sharedArguments,
+            load: async (args) => {
+                try {
+                    const text = await (0, workspace_1.readWorkspaceFile)(root, args.path);
+                    return { text: String(text) };
+                }
+                catch (err) {
+                    throw err;
+                }
+            },
+        },
+    ];
+    exports.workspaceResourceTemplates.splice(0, exports.workspaceResourceTemplates.length, ...templates);
+    return exports.workspaceResourceTemplates;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/mcp/templates/workspace-templates.d.ts

@@ -0,0 +1,3 @@
+import { WorkspaceResourceTemplate } from "../types";
+export declare const workspaceResourceTemplates: WorkspaceResourceTemplate[];
+export declare function buildWorkspaceResourceTemplates(): WorkspaceResourceTemplate[];

package/lib/mcp/tools/codex-tools.cjs

@@ -0,0 +1,250 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readmeImprovementTool = exports.coverageEnforcerTool = exports.documentObjectTool = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const schemas_1 = require("./../schemas.cjs");
+const workspace_1 = require("./../workspace.cjs");
+const prompts_1 = require("./../prompts/prompts.cjs");
+const utils_1 = require("./../utils.cjs");
+const code_1 = require("./../code.cjs");
+function relativeFiles(root, files) {
+    return files.map((file) => path_1.default.relative(root, file)).sort();
+}
+function collectPromptSections(names) {
+    const root = (0, workspace_1.getWorkspaceRoot)();
+    const promptIndex = new Map((0, prompts_1.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_1.default.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 = (0, workspace_1.getWorkspaceRoot)();
+    try {
+        return (0, workspace_1.resolveInWorkspace)(root, basePath);
+    }
+    catch (error) {
+        if (error instanceof workspace_1.WorkspaceError) {
+            await (0, workspace_1.throwUserError)(error.message);
+        }
+        throw error;
+    }
+}
+exports.documentObjectTool = {
+    name: "document-object",
+    description: "Create a documentation plan for a specific object type using .codex prompts and repository analysis.",
+    parameters: schemas_1.documentObjectSchema,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute: async (input, _context) => {
+        const args = schemas_1.documentObjectSchema.parse(input);
+        const repoRoot = await resolveRepoRoot(args.basePath);
+        const dependencies = (0, prompts_1.getObjectPromptDependencies)()[args.objectType] ?? [];
+        if (!dependencies.length) {
+            await (0, workspace_1.throwUserError)(`No prompt guidance configured for object type ${args.objectType}`);
+        }
+        const sections = normalizePromptSections(collectPromptSections(dependencies));
+        const srcDir = path_1.default.join(repoRoot, "src");
+        const testDir = path_1.default.join(repoRoot, "tests");
+        const sourceFiles = fs_1.default.existsSync(srcDir)
+            ? (0, utils_1.listFilesRecursive)(srcDir, code_1.isSourceFile)
+            : [];
+        const testFiles = fs_1.default.existsSync(testDir)
+            ? (0, utils_1.listFilesRecursive)(testDir, (file) => (0, code_1.isSourceFile)(file) && (0, code_1.isTestFile)(file))
+            : [];
+        let targetFileContent;
+        if (args.targetFile) {
+            try {
+                const absolute = (0, workspace_1.resolveInWorkspace)(repoRoot, args.targetFile);
+                targetFileContent = (0, utils_1.readFileSafe)(absolute) ?? undefined;
+            }
+            catch (error) {
+                if (error instanceof workspace_1.WorkspaceError) {
+                    await (0, workspace_1.throwUserError)(error.message);
+                }
+                throw error;
+            }
+        }
+        const payload = {
+            basePath: path_1.default.relative((0, workspace_1.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),
+                },
+            ],
+        };
+    },
+};
+exports.coverageEnforcerTool = {
+    name: "ensure-test-coverage",
+    description: "Run the configured coverage command and report whether the target percentage is met, highlighting weak files.",
+    parameters: schemas_1.coverageTaskSchema,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute: async (input, _context) => {
+        const args = schemas_1.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 = (0, child_process_1.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 (0, workspace_1.throwUserError)(message.trim());
+            }
+        }
+        const coveragePath = path_1.default.join(repoRoot, "workdocs", "reports", "coverage", "coverage-final.json");
+        if (!fs_1.default.existsSync(coveragePath)) {
+            await (0, workspace_1.throwUserError)(`Coverage report not found at ${path_1.default.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_1.default.relative((0, workspace_1.getWorkspaceRoot)(), repoRoot) || ".",
+            target: args.coverage,
+            meetsThreshold,
+            totals: summary.totals,
+            weakest,
+            guidance,
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(payload, null, 2),
+                },
+            ],
+        };
+    },
+};
+exports.readmeImprovementTool = {
+    name: "improve-readme",
+    description: "Summarize required steps to refresh README and workdocs content using .codex guidance and repository analysis.",
+    parameters: schemas_1.readmeImprovementSchema,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute: async (input, _context) => {
+        const args = schemas_1.readmeImprovementSchema.parse(input);
+        const repoRoot = await resolveRepoRoot(args.basePath);
+        const analysis = (0, code_1.analyzeRepo)(repoRoot);
+        const modules = analysis.files
+            .filter((file) => /index\.ts$/.test(file))
+            .map((file) => path_1.default.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_1.default.relative((0, workspace_1.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/mcp/tools/codex-tools.d.ts

@@ -0,0 +1,5 @@
+import type { Tool } from "fastmcp";
+import { documentObjectSchema, coverageTaskSchema, readmeImprovementSchema } from "../schemas";
+export declare const documentObjectTool: Tool<undefined, typeof documentObjectSchema>;
+export declare const coverageEnforcerTool: Tool<undefined, typeof coverageTaskSchema>;
+export declare const readmeImprovementTool: Tool<undefined, typeof readmeImprovementSchema>;