@decaf-ts/mcp-server 0.0.4 → 0.2.0

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

@@ -0,0 +1,53 @@
+import { z } from "zod";
+export declare const analyzeRepoSchema: z.ZodObject<{
+    repoPath: z.ZodString;
+    includeTests: z.ZodDefault<z.ZodBoolean>;
+    includeDocs: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const enumerateCapabilitiesSchema: z.ZodObject<{
+    repoPath: z.ZodString;
+}, z.core.$strict>;
+export declare const planFeatureSchema: z.ZodObject<{
+    feature: z.ZodString;
+    repoPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export declare const documentCodeSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    promptName: z.ZodOptional<z.ZodString>;
+    includePrompt: z.ZodDefault<z.ZodBoolean>;
+    includeCode: z.ZodDefault<z.ZodBoolean>;
+    includeMetadata: z.ZodDefault<z.ZodBoolean>;
+    additionalContext: z.ZodOptional<z.ZodString>;
+    encoding: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export declare const codeChangeSchema: z.ZodObject<{
+    filePath: z.ZodString;
+    patch: z.ZodString;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+    showDiff: z.ZodDefault<z.ZodBoolean>;
+    diffContext: z.ZodDefault<z.ZodNumber>;
+    encoding: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+export declare const documentObjectSchema: z.ZodObject<{
+    basePath: z.ZodString;
+    objectType: z.ZodEnum<{
+        function: "function";
+        module: "module";
+        file: "file";
+        class: "class";
+        interface: "interface";
+        decorator: "decorator";
+        constant: "constant";
+    }>;
+    targetFile: z.ZodOptional<z.ZodString>;
+    includeContent: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const coverageTaskSchema: z.ZodObject<{
+    basePath: z.ZodString;
+    coverage: z.ZodDefault<z.ZodNumber>;
+    dryRun: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const readmeImprovementSchema: z.ZodObject<{
+    basePath: z.ZodString;
+    includeExamples: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;

package/lib/esm/mcp/schemas.js

@@ -0,0 +1,97 @@
+import { z } from "zod";
+export const analyzeRepoSchema = z
+    .object({
+    repoPath: z
+        .string()
+        .min(1, "repoPath is required")
+        .describe("Relative or absolute path to the target repository inside this monorepo, e.g. './decoration'."),
+    includeTests: z
+        .boolean()
+        .default(true)
+        .describe("If true, analyze the tests directory (if present) to derive expected behaviors."),
+    includeDocs: z
+        .boolean()
+        .default(true)
+        .describe("If true, analyze README.md and docs directories to extract documented features."),
+})
+    .strict()
+    .describe("Analyze a local repository (e.g. ./decoration) to extract APIs, features, tests, and documentation cues.");
+export const enumerateCapabilitiesSchema = z
+    .object({
+    repoPath: z
+        .string()
+        .min(1, "repoPath is required")
+        .describe("Relative or absolute path to the target repository to enumerate developer-facing capabilities."),
+})
+    .strict()
+    .describe("Enumerate the complete set of capabilities a developer is expected to use from the given repository.");
+export const planFeatureSchema = z
+    .object({
+    feature: z
+        .string()
+        .min(5, "feature must describe the goal clearly")
+        .describe("Natural-language description of a developer's requested feature or task to implement using the repository and available MCP tools."),
+    repoPath: z
+        .string()
+        .default("./decoration")
+        .describe("Target repository path providing the library to use, e.g. './decoration'."),
+})
+    .strict()
+    .describe("Plan which MCP tools to use and in what sequence to implement a requested feature using the repository.");
+export const documentCodeSchema = z
+    .object({
+    filePath: z.string().min(1, "filePath is required"),
+    promptName: z.string().optional(),
+    includePrompt: z.boolean().default(true),
+    includeCode: z.boolean().default(true),
+    includeMetadata: z.boolean().default(true),
+    additionalContext: z.string().optional(),
+    encoding: z.string().default("utf8"),
+})
+    .strict();
+export const codeChangeSchema = z
+    .object({
+    filePath: z.string().min(1, "filePath is required"),
+    patch: z.string().min(1, "patch is required"),
+    dryRun: z.boolean().default(false),
+    showDiff: z.boolean().default(true),
+    diffContext: z.number().int().min(0).max(100).default(3),
+    encoding: z.string().default("utf8"),
+})
+    .strict();
+const OBJECT_TYPES = [
+    "module",
+    "file",
+    "class",
+    "function",
+    "interface",
+    "decorator",
+    "constant",
+];
+export const documentObjectSchema = z
+    .object({
+    basePath: z.string().min(1, "basePath is required"),
+    objectType: z.enum(OBJECT_TYPES),
+    targetFile: z.string().optional(),
+    includeContent: z.boolean().default(false),
+})
+    .strict();
+export const coverageTaskSchema = z
+    .object({
+    basePath: z.string().min(1, "basePath is required"),
+    coverage: z
+        .number()
+        .min(0)
+        .max(100)
+        .default(90)
+        .describe("Target coverage percentage"),
+    dryRun: z.boolean().default(false),
+})
+    .strict();
+export const readmeImprovementSchema = z
+    .object({
+    basePath: z.string().min(1, "basePath is required"),
+    includeExamples: z.boolean().default(true),
+})
+    .strict();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schemas.js","sourceRoot":"","sources":["../../../src/mcp/schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from \"zod\";\n\nexport const analyzeRepoSchema = z\n  .object({\n    repoPath: z\n      .string()\n      .min(1, \"repoPath is required\")\n      .describe(\n        \"Relative or absolute path to the target repository inside this monorepo, e.g. './decoration'.\"\n      ),\n    includeTests: z\n      .boolean()\n      .default(true)\n      .describe(\n        \"If true, analyze the tests directory (if present) to derive expected behaviors.\"\n      ),\n    includeDocs: z\n      .boolean()\n      .default(true)\n      .describe(\n        \"If true, analyze README.md and docs directories to extract documented features.\"\n      ),\n  })\n  .strict()\n  .describe(\n    \"Analyze a local repository (e.g. ./decoration) to extract APIs, features, tests, and documentation cues.\"\n  );\n\nexport const enumerateCapabilitiesSchema = z\n  .object({\n    repoPath: z\n      .string()\n      .min(1, \"repoPath is required\")\n      .describe(\n        \"Relative or absolute path to the target repository to enumerate developer-facing capabilities.\"\n      ),\n  })\n  .strict()\n  .describe(\n    \"Enumerate the complete set of capabilities a developer is expected to use from the given repository.\"\n  );\n\nexport const planFeatureSchema = z\n  .object({\n    feature: z\n      .string()\n      .min(5, \"feature must describe the goal clearly\")\n      .describe(\n        \"Natural-language description of a developer's requested feature or task to implement using the repository and available MCP tools.\"\n      ),\n    repoPath: z\n      .string()\n      .default(\"./decoration\")\n      .describe(\n        \"Target repository path providing the library to use, e.g. './decoration'.\"\n      ),\n  })\n  .strict()\n  .describe(\n    \"Plan which MCP tools to use and in what sequence to implement a requested feature using the repository.\"\n  );\n\nexport const documentCodeSchema = z\n  .object({\n    filePath: z.string().min(1, \"filePath is required\"),\n    promptName: z.string().optional(),\n    includePrompt: z.boolean().default(true),\n    includeCode: z.boolean().default(true),\n    includeMetadata: z.boolean().default(true),\n    additionalContext: z.string().optional(),\n    encoding: z.string().default(\"utf8\"),\n  })\n  .strict();\n\nexport const codeChangeSchema = z\n  .object({\n    filePath: z.string().min(1, \"filePath is required\"),\n    patch: z.string().min(1, \"patch is required\"),\n    dryRun: z.boolean().default(false),\n    showDiff: z.boolean().default(true),\n    diffContext: z.number().int().min(0).max(100).default(3),\n    encoding: z.string().default(\"utf8\"),\n  })\n  .strict();\n\nconst OBJECT_TYPES = [\n  \"module\",\n  \"file\",\n  \"class\",\n  \"function\",\n  \"interface\",\n  \"decorator\",\n  \"constant\",\n] as const;\n\nexport const documentObjectSchema = z\n  .object({\n    basePath: z.string().min(1, \"basePath is required\"),\n    objectType: z.enum(OBJECT_TYPES),\n    targetFile: z.string().optional(),\n    includeContent: z.boolean().default(false),\n  })\n  .strict();\n\nexport const coverageTaskSchema = z\n  .object({\n    basePath: z.string().min(1, \"basePath is required\"),\n    coverage: z\n      .number()\n      .min(0)\n      .max(100)\n      .default(90)\n      .describe(\"Target coverage percentage\"),\n    dryRun: z.boolean().default(false),\n  })\n  .strict();\n\nexport const readmeImprovementSchema = z\n  .object({\n    basePath: z.string().min(1, \"basePath is required\"),\n    includeExamples: z.boolean().default(true),\n  })\n  .strict();\n"]}

package/lib/esm/mcp/templates/codex-templates.d.ts

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

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

@@ -0,0 +1,33 @@
+import path from "path";
+import fs from "fs";
+import { getWorkspaceRoot, resolveInWorkspace } from "../workspace";
+export const codexPromptTemplates = [];
+export function buildCodexPromptTemplates() {
+    const root = getWorkspaceRoot();
+    const templates = [
+        {
+            name: "codex-prompt",
+            description: "Load a .codex prompt file by name (without extension) as markdown.",
+            uriTemplate: "codex-prompt://{name}",
+            mimeType: "text/markdown",
+            arguments: [
+                {
+                    name: "name",
+                    description: "Name of the prompt file inside .codex/prompts (without .md).",
+                    required: true,
+                },
+            ],
+            load: async ({ name }) => {
+                const promptPath = resolveInWorkspace(root, path.join(".codex", "prompts", `${name}.md`));
+                if (!fs.existsSync(promptPath)) {
+                    throw new Error(`Prompt .codex/prompts/${name}.md not found`);
+                }
+                const text = fs.readFileSync(promptPath, "utf8");
+                return { text, uri: `codex-prompt:///${name}` };
+            },
+        },
+    ];
+    codexPromptTemplates.splice(0, codexPromptTemplates.length, ...templates);
+    return codexPromptTemplates;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/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/esm/mcp/templates/index.js

@@ -0,0 +1,66 @@
+import { buildCodexPromptTemplates, } from "./codex-templates";
+import { buildDecorationResourceTemplates, } from "./resource-templates";
+import { buildWorkspaceResourceTemplates, } from "./workspace-templates";
+import { moduleRegistry } from "../moduleRegistry";
+export { buildCodexPromptTemplates, codexPromptTemplates, } from "./codex-templates";
+export { buildDecorationResourceTemplates, decorationResourceTemplates, } from "./resource-templates";
+export { buildWorkspaceResourceTemplates, workspaceResourceTemplates, } from "./workspace-templates";
+export function buildResourceTemplates() {
+    const moduleTemplates = 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 = [
+        ...buildWorkspaceResourceTemplates(),
+        ...buildCodexPromptTemplates(),
+        ...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);
+        },
+    }));
+}
+export const templateList = buildResourceTemplates();
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/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/esm/mcp/templates/resource-templates.js

@@ -0,0 +1,60 @@
+import path from "path";
+import { getWorkspaceRoot, readWorkspaceFile } from "../workspace";
+export const decorationResourceTemplates = [];
+function makeLoader(type) {
+    return async ({ path: relative }) => {
+        const root = getWorkspaceRoot();
+        const target = path.join(type, relative);
+        const text = await readWorkspaceFile(root, target);
+        return { text };
+    };
+}
+export 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"),
+        },
+    ];
+    decorationResourceTemplates.splice(0, decorationResourceTemplates.length, ...templates);
+    return decorationResourceTemplates;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb3VyY2UtdGVtcGxhdGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL21jcC90ZW1wbGF0ZXMvcmVzb3VyY2UtdGVtcGxhdGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sSUFBSSxNQUFNLE1BQU0sQ0FBQztBQUV4QixPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxjQUFjLENBQUM7QUFFbkUsTUFBTSxDQUFDLE1BQU0sMkJBQTJCLEdBQWlDLEVBQUUsQ0FBQztBQUU1RSxTQUFTLFVBQVUsQ0FBQyxJQUFrQztJQUNwRCxPQUFPLEtBQUssRUFBRSxFQUFFLElBQUksRUFBRSxRQUFRLEVBQW9CLEVBQUUsRUFBRTtRQUNwRCxNQUFNLElBQUksR0FBRyxnQkFBZ0IsRUFBRSxDQUFDO1FBQ2hDLE1BQU0sTUFBTSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBQ3pDLE1BQU0sSUFBSSxHQUFHLE1BQU0saUJBQWlCLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDO1FBQ25ELE9BQU8sRUFBRSxJQUFJLEVBQUUsQ0FBQztJQUNsQixDQUFDLENBQUM7QUFDSixDQUFDO0FBRUQsTUFBTSxVQUFVLGdDQUFnQztJQUM5QyxNQUFNLFNBQVMsR0FBaUM7UUFDOUM7WUFDRSxJQUFJLEVBQUUsdUJBQXVCO1lBQzdCLFdBQVcsRUFDVCw2REFBNkQ7WUFDL0QsUUFBUSxFQUFFLFlBQVk7WUFDdEIsV0FBVyxFQUFFLDBCQUEwQjtZQUN2QyxTQUFTLEVBQUU7Z0JBQ1Q7b0JBQ0UsSUFBSSxFQUFFLE1BQU07b0JBQ1osV0FBVyxFQUNULGdFQUFnRTtvQkFDbEUsUUFBUSxFQUFFLElBQUk7aUJBQ2Y7YUFDRjtZQUNELElBQUksRUFBRSxVQUFVLENBQUMsS0FBSyxDQUFDO1NBQ3hCO1FBQ0Q7WUFDRSxJQUFJLEVBQUUsdUJBQXVCO1lBQzdCLFdBQVcsRUFDVCwrREFBK0Q7WUFDakUsUUFBUSxFQUFFLFlBQVk7WUFDdEIsV0FBVyxFQUFFLDRCQUE0QjtZQUN6QyxTQUFTLEVBQUU7Z0JBQ1Q7b0JBQ0UsSUFBSSxFQUFFLE1BQU07b0JBQ1osV0FBVyxFQUNULDZFQUE2RTtvQkFDL0UsUUFBUSxFQUFFLElBQUk7aUJBQ2Y7YUFDRjtZQUNELElBQUksRUFBRSxVQUFVLENBQUMsT0FBTyxDQUFDO1NBQzFCO1FBQ0Q7WUFDRSxJQUFJLEVBQUUsc0JBQXNCO1lBQzVCLFdBQVcsRUFDVCxrRUFBa0U7WUFDcEUsUUFBUSxFQUFFLFlBQVk7WUFDdEIsV0FBVyxFQUFFLCtCQUErQjtZQUM1QyxTQUFTLEVBQUU7Z0JBQ1Q7b0JBQ0UsSUFBSSxFQUFFLE1BQU07b0JBQ1osV0FBVyxFQUNULGlHQUFpRztvQkFDbkcsUUFBUSxFQUFFLElBQUk7aUJBQ2Y7YUFDRjtZQUNELElBQUksRUFBRSxVQUFVLENBQUMsVUFBVSxDQUFDO1NBQzdCO0tBQ0YsQ0FBQztJQUVGLDJCQUEyQixDQUFDLE1BQU0sQ0FDaEMsQ0FBQyxFQUNELDJCQUEyQixDQUFDLE1BQU0sRUFDbEMsR0FBRyxTQUFTLENBQ2IsQ0FBQztJQUNGLE9BQU8sMkJBQTJCLENBQUM7QUFDckMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBwYXRoIGZyb20gXCJwYXRoXCI7XG5pbXBvcnQgdHlwZSB7IERlY29yYXRpb25SZXNvdXJjZVRlbXBsYXRlIH0gZnJvbSBcIi4uL3R5cGVzXCI7XG5pbXBvcnQgeyBnZXRXb3Jrc3BhY2VSb290LCByZWFkV29ya3NwYWNlRmlsZSB9IGZyb20gXCIuLi93b3Jrc3BhY2VcIjtcblxuZXhwb3J0IGNvbnN0IGRlY29yYXRpb25SZXNvdXJjZVRlbXBsYXRlczogRGVjb3JhdGlvblJlc291cmNlVGVtcGxhdGVbXSA9IFtdO1xuXG5mdW5jdGlvbiBtYWtlTG9hZGVyKHR5cGU6IFwic3JjXCIgfCBcInRlc3RzXCIgfCBcIndvcmtkb2NzXCIpIHtcbiAgcmV0dXJuIGFzeW5jICh7IHBhdGg6IHJlbGF0aXZlIH06IHsgcGF0aDogc3RyaW5nIH0pID0+IHtcbiAgICBjb25zdCByb290ID0gZ2V0V29ya3NwYWNlUm9vdCgpO1xuICAgIGNvbnN0IHRhcmdldCA9IHBhdGguam9pbih0eXBlLCByZWxhdGl2ZSk7XG4gICAgY29uc3QgdGV4dCA9IGF3YWl0IHJlYWRXb3Jrc3BhY2VGaWxlKHJvb3QsIHRhcmdldCk7XG4gICAgcmV0dXJuIHsgdGV4dCB9O1xuICB9O1xufVxuXG5leHBvcnQgZnVuY3Rpb24gYnVpbGREZWNvcmF0aW9uUmVzb3VyY2VUZW1wbGF0ZXMoKTogRGVjb3JhdGlvblJlc291cmNlVGVtcGxhdGVbXSB7XG4gIGNvbnN0IHRlbXBsYXRlczogRGVjb3JhdGlvblJlc291cmNlVGVtcGxhdGVbXSA9IFtcbiAgICB7XG4gICAgICBuYW1lOiBcInJlYWQtY29kZS1mcm9tLXNvdXJjZVwiLFxuICAgICAgZGVzY3JpcHRpb246XG4gICAgICAgIFwiUmVhZCBhIGZpbGUgZnJvbSB0aGUgPGJhc2VfcGF0aD4vc3JjIHRyZWUgYnkgcmVsYXRpdmUgcGF0aC5cIixcbiAgICAgIG1pbWVUeXBlOiBcInRleHQvcGxhaW5cIixcbiAgICAgIHVyaVRlbXBsYXRlOiBcImZyb20tc291cmNlOi8vc3JjL3twYXRofVwiLFxuICAgICAgYXJndW1lbnRzOiBbXG4gICAgICAgIHtcbiAgICAgICAgICBuYW1lOiBcInBhdGhcIixcbiAgICAgICAgICBkZXNjcmlwdGlvbjpcbiAgICAgICAgICAgIFwiUGF0aCB1bmRlciA8YmFzZV9wYXRoPi9zcmMgdG8gbG9hZCwgZS5nLiAnZGVjb3JhdGlvbi90eXBlcy50cydcIixcbiAgICAgICAgICByZXF1aXJlZDogdHJ1ZSxcbiAgICAgICAgfSxcbiAgICAgIF0sXG4gICAgICBsb2FkOiBtYWtlTG9hZGVyKFwic3JjXCIpLFxuICAgIH0sXG4gICAge1xuICAgICAgbmFtZTogXCJyZWFkLXRlc3QtZnJvbS1zb3VyY2VcIixcbiAgICAgIGRlc2NyaXB0aW9uOlxuICAgICAgICBcIlJlYWQgYSBmaWxlIGZyb20gdGhlIDxiYXNlX3BhdGg+L3Rlc3RzIHRyZWUgYnkgcmVsYXRpdmUgcGF0aC5cIixcbiAgICAgIG1pbWVUeXBlOiBcInRleHQvcGxhaW5cIixcbiAgICAgIHVyaVRlbXBsYXRlOiBcImZyb20tc291cmNlOi8vdGVzdHMve3BhdGh9XCIsXG4gICAgICBhcmd1bWVudHM6IFtcbiAgICAgICAge1xuICAgICAgICAgIG5hbWU6IFwicGF0aFwiLFxuICAgICAgICAgIGRlc2NyaXB0aW9uOlxuICAgICAgICAgICAgXCJQYXRoIHVuZGVyIDxiYXNlX3BhdGg+L3Rlc3RzIHRvIGxvYWQsIGUuZy4gJ2RlY29yYXRpb24vdGVzdHMvdHlwZXMudGVzdC50cydcIixcbiAgICAgICAgICByZXF1aXJlZDogdHJ1ZSxcbiAgICAgICAgfSxcbiAgICAgIF0sXG4gICAgICBsb2FkOiBtYWtlTG9hZGVyKFwidGVzdHNcIiksXG4gICAgfSxcbiAgICB7XG4gICAgICBuYW1lOiBcInJlYWQtZG9jLWZyb20tc291cmNlXCIsXG4gICAgICBkZXNjcmlwdGlvbjpcbiAgICAgICAgXCJSZWFkIGEgZmlsZSBmcm9tIHRoZSA8YmFzZV9wYXRoPi93b3JrZG9jcyB0cmVlIGJ5IHJlbGF0aXZlIHBhdGguXCIsXG4gICAgICBtaW1lVHlwZTogXCJ0ZXh0L3BsYWluXCIsXG4gICAgICB1cmlUZW1wbGF0ZTogXCJmcm9tLXNvdXJjZTovL3dvcmtkb2NzL3twYXRofVwiLFxuICAgICAgYXJndW1lbnRzOiBbXG4gICAgICAgIHtcbiAgICAgICAgICBuYW1lOiBcInBhdGhcIixcbiAgICAgICAgICBkZXNjcmlwdGlvbjpcbiAgICAgICAgICAgIFwiUGF0aCB1bmRlciA8YmFzZV9wYXRoPi93b3JrZG9jcyB0byBsb2FkLCBlLmcuICdkZWNvcmF0aW9uL3dvcmtkb2NzL3R1dG9yaWFscy9mb3ItZGV2ZWxvcGVycy5tZCdcIixcbiAgICAgICAgICByZXF1aXJlZDogdHJ1ZSxcbiAgICAgICAgfSxcbiAgICAgIF0sXG4gICAgICBsb2FkOiBtYWtlTG9hZGVyKFwid29ya2RvY3NcIiksXG4gICAgfSxcbiAgXTtcblxuICBkZWNvcmF0aW9uUmVzb3VyY2VUZW1wbGF0ZXMuc3BsaWNlKFxuICAgIDAsXG4gICAgZGVjb3JhdGlvblJlc291cmNlVGVtcGxhdGVzLmxlbmd0aCxcbiAgICAuLi50ZW1wbGF0ZXNcbiAgKTtcbiAgcmV0dXJuIGRlY29yYXRpb25SZXNvdXJjZVRlbXBsYXRlcztcbn1cbiJdfQ==

package/lib/esm/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/esm/mcp/templates/workspace-templates.js

@@ -0,0 +1,66 @@
+import { getWorkspaceRoot, readWorkspaceFile } from "../workspace";
+export const workspaceResourceTemplates = [];
+export function buildWorkspaceResourceTemplates() {
+    const root = 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 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 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 readWorkspaceFile(root, args.path);
+                    return { text: String(text) };
+                }
+                catch (err) {
+                    throw err;
+                }
+            },
+        },
+    ];
+    workspaceResourceTemplates.splice(0, workspaceResourceTemplates.length, ...templates);
+    return workspaceResourceTemplates;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid29ya3NwYWNlLXRlbXBsYXRlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9tY3AvdGVtcGxhdGVzL3dvcmtzcGFjZS10ZW1wbGF0ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLGdCQUFnQixFQUFFLGlCQUFpQixFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRW5FLE1BQU0sQ0FBQyxNQUFNLDBCQUEwQixHQUFnQyxFQUFFLENBQUM7QUFFMUUsTUFBTSxVQUFVLCtCQUErQjtJQUM3QyxNQUFNLElBQUksR0FBRyxnQkFBZ0IsRUFBRSxDQUFDO0lBQ2hDLE1BQU0sZUFBZSxHQUFHO1FBQ3RCO1lBQ0UsSUFBSSxFQUFFLE1BQU07WUFDWixXQUFXLEVBQUUscUNBQXFDO1lBQ2xELFFBQVEsRUFBRSxJQUFJO1NBQ2Y7S0FDTyxDQUFDO0lBRVgsTUFBTSxTQUFTLEdBQWdDO1FBQzdDO1lBQ0UsSUFBSSxFQUFFLHVCQUF1QjtZQUM3QixXQUFXLEVBQ1QsaUVBQWlFO1lBQ25FLFdBQVcsRUFBRSwyQkFBMkI7WUFDeEMsUUFBUSxFQUFFLFlBQVk7WUFDdEIsU0FBUyxFQUFFLGVBQWU7WUFDMUIsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFzQixFQUFFLEVBQUU7Z0JBQ3JDLElBQUksQ0FBQztvQkFDSCxNQUFNLElBQUksR0FBRyxNQUFNLGlCQUFpQixDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7b0JBQ3RELE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7Z0JBQ2hDLENBQUM7Z0JBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztvQkFDYiw2Q0FBNkM7b0JBQzdDLE1BQU0sR0FBRyxDQUFDO2dCQUNaLENBQUM7WUFDSCxDQUFDO1NBQ0Y7UUFDRDtZQUNFLElBQUksRUFBRSx1QkFBdUI7WUFDN0IsV0FBVyxFQUFFLHFEQUFxRDtZQUNsRSxXQUFXLEVBQUUsMkJBQTJCO1lBQ3hDLFFBQVEsRUFBRSxZQUFZO1lBQ3RCLFNBQVMsRUFBRSxlQUFlO1lBQzFCLElBQUksRUFBRSxLQUFLLEVBQUUsSUFBc0IsRUFBRSxFQUFFO2dCQUNyQyxJQUFJLENBQUM7b0JBQ0gsTUFBTSxJQUFJLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQyxJQUFJLEVBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO29CQUN0RCxPQUFPLEVBQUUsSUFBSSxFQUFFLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDO2dCQUNoQyxDQUFDO2dCQUFDLE9BQU8sR0FBRyxFQUFFLENBQUM7b0JBQ2IsTUFBTSxHQUFHLENBQUM7Z0JBQ1osQ0FBQztZQUNILENBQUM7U0FDRjtRQUNEO1lBQ0UsSUFBSSxFQUFFLHdCQUF3QjtZQUM5QixXQUFXLEVBQ1QsOERBQThEO1lBQ2hFLFdBQVcsRUFBRSw0QkFBNEI7WUFDekMsUUFBUSxFQUFFLFlBQVk7WUFDdEIsU0FBUyxFQUFFLGVBQWU7WUFDMUIsSUFBSSxFQUFFLEtBQUssRUFBRSxJQUFzQixFQUFFLEVBQUU7Z0JBQ3JDLElBQUksQ0FBQztvQkFDSCxNQUFNLElBQUksR0FBRyxNQUFNLGlCQUFpQixDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7b0JBQ3RELE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7Z0JBQ2hDLENBQUM7Z0JBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQztvQkFDYixNQUFNLEdBQUcsQ0FBQztnQkFDWixDQUFDO1lBQ0gsQ0FBQztTQUNGO0tBQ0YsQ0FBQztJQUVGLDBCQUEwQixDQUFDLE1BQU0sQ0FDL0IsQ0FBQyxFQUNELDBCQUEwQixDQUFDLE1BQU0sRUFDakMsR0FBRyxTQUFTLENBQ2IsQ0FBQztJQUNGLE9BQU8sMEJBQTBCLENBQUM7QUFDcEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFdvcmtzcGFjZVJlc291cmNlVGVtcGxhdGUgfSBmcm9tIFwiLi4vdHlwZXNcIjtcbmltcG9ydCB7IGdldFdvcmtzcGFjZVJvb3QsIHJlYWRXb3Jrc3BhY2VGaWxlIH0gZnJvbSBcIi4uL3dvcmtzcGFjZVwiO1xuXG5leHBvcnQgY29uc3Qgd29ya3NwYWNlUmVzb3VyY2VUZW1wbGF0ZXM6IFdvcmtzcGFjZVJlc291cmNlVGVtcGxhdGVbXSA9IFtdO1xuXG5leHBvcnQgZnVuY3Rpb24gYnVpbGRXb3Jrc3BhY2VSZXNvdXJjZVRlbXBsYXRlcygpOiBXb3Jrc3BhY2VSZXNvdXJjZVRlbXBsYXRlW10ge1xuICBjb25zdCByb290ID0gZ2V0V29ya3NwYWNlUm9vdCgpO1xuICBjb25zdCBzaGFyZWRBcmd1bWVudHMgPSBbXG4gICAge1xuICAgICAgbmFtZTogXCJwYXRoXCIsXG4gICAgICBkZXNjcmlwdGlvbjogXCJQYXRoIHJlbGF0aXZlIHRvIHRoZSB3b3Jrc3BhY2Ugcm9vdFwiLFxuICAgICAgcmVxdWlyZWQ6IHRydWUsXG4gICAgfSxcbiAgXSBhcyBjb25zdDtcblxuICBjb25zdCB0ZW1wbGF0ZXM6IFdvcmtzcGFjZVJlc291cmNlVGVtcGxhdGVbXSA9IFtcbiAgICB7XG4gICAgICBuYW1lOiBcInZzY29kZS13b3Jrc3BhY2UtZmlsZVwiLFxuICAgICAgZGVzY3JpcHRpb246XG4gICAgICAgIFwiRXhwb3NlIHdvcmtzcGFjZSBmaWxlcyB0byBWaXN1YWwgU3R1ZGlvIENvZGUgdmlhIHZzY29kZTovLyBVUklzXCIsXG4gICAgICB1cmlUZW1wbGF0ZTogXCJ2c2NvZGU6Ly93b3Jrc3BhY2Uve3BhdGh9XCIsXG4gICAgICBtaW1lVHlwZTogXCJ0ZXh0L3BsYWluXCIsXG4gICAgICBhcmd1bWVudHM6IHNoYXJlZEFyZ3VtZW50cyxcbiAgICAgIGxvYWQ6IGFzeW5jIChhcmdzOiB7IHBhdGg6IHN0cmluZyB9KSA9PiB7XG4gICAgICAgIHRyeSB7XG4gICAgICAgICAgY29uc3QgdGV4dCA9IGF3YWl0IHJlYWRXb3Jrc3BhY2VGaWxlKHJvb3QsIGFyZ3MucGF0aCk7XG4gICAgICAgICAgcmV0dXJuIHsgdGV4dDogU3RyaW5nKHRleHQpIH07XG4gICAgICAgIH0gY2F0Y2ggKGVycikge1xuICAgICAgICAgIC8vIHByb3BhZ2F0ZSBhcy1pcyBmb3IgdGVzdHMgdG8gYXNzZXJ0IGVycm9yc1xuICAgICAgICAgIHRocm93IGVycjtcbiAgICAgICAgfVxuICAgICAgfSxcbiAgICB9LFxuICAgIHtcbiAgICAgIG5hbWU6IFwiY3Vyc29yLXdvcmtzcGFjZS1maWxlXCIsXG4gICAgICBkZXNjcmlwdGlvbjogXCJFeHBvc2Ugd29ya3NwYWNlIGZpbGVzIHRvIEN1cnNvciB2aWEgY3Vyc29yOi8vIFVSSXNcIixcbiAgICAgIHVyaVRlbXBsYXRlOiBcImN1cnNvcjovL3dvcmtzcGFjZS97cGF0aH1cIixcbiAgICAgIG1pbWVUeXBlOiBcInRleHQvcGxhaW5cIixcbiAgICAgIGFyZ3VtZW50czogc2hhcmVkQXJndW1lbnRzLFxuICAgICAgbG9hZDogYXN5bmMgKGFyZ3M6IHsgcGF0aDogc3RyaW5nIH0pID0+IHtcbiAgICAgICAgdHJ5IHtcbiAgICAgICAgICBjb25zdCB0ZXh0ID0gYXdhaXQgcmVhZFdvcmtzcGFjZUZpbGUocm9vdCwgYXJncy5wYXRoKTtcbiAgICAgICAgICByZXR1cm4geyB0ZXh0OiBTdHJpbmcodGV4dCkgfTtcbiAgICAgICAgfSBjYXRjaCAoZXJyKSB7XG4gICAgICAgICAgdGhyb3cgZXJyO1xuICAgICAgICB9XG4gICAgICB9LFxuICAgIH0sXG4gICAge1xuICAgICAgbmFtZTogXCJjb3BpbG90LXdvcmtzcGFjZS1maWxlXCIsXG4gICAgICBkZXNjcmlwdGlvbjpcbiAgICAgICAgXCJFeHBvc2Ugd29ya3NwYWNlIGZpbGVzIHRvIEdpdEh1YiBDb3BpbG90IHZpYSBjb3BpbG90Oi8vIFVSSXNcIixcbiAgICAgIHVyaVRlbXBsYXRlOiBcImNvcGlsb3Q6Ly93b3Jrc3BhY2Uve3BhdGh9XCIsXG4gICAgICBtaW1lVHlwZTogXCJ0ZXh0L3BsYWluXCIsXG4gICAgICBhcmd1bWVudHM6IHNoYXJlZEFyZ3VtZW50cyxcbiAgICAgIGxvYWQ6IGFzeW5jIChhcmdzOiB7IHBhdGg6IHN0cmluZyB9KSA9PiB7XG4gICAgICAgIHRyeSB7XG4gICAgICAgICAgY29uc3QgdGV4dCA9IGF3YWl0IHJlYWRXb3Jrc3BhY2VGaWxlKHJvb3QsIGFyZ3MucGF0aCk7XG4gICAgICAgICAgcmV0dXJuIHsgdGV4dDogU3RyaW5nKHRleHQpIH07XG4gICAgICAgIH0gY2F0Y2ggKGVycikge1xuICAgICAgICAgIHRocm93IGVycjtcbiAgICAgICAgfVxuICAgICAgfSxcbiAgICB9LFxuICBdO1xuXG4gIHdvcmtzcGFjZVJlc291cmNlVGVtcGxhdGVzLnNwbGljZShcbiAgICAwLFxuICAgIHdvcmtzcGFjZVJlc291cmNlVGVtcGxhdGVzLmxlbmd0aCxcbiAgICAuLi50ZW1wbGF0ZXNcbiAgKTtcbiAgcmV0dXJuIHdvcmtzcGFjZVJlc291cmNlVGVtcGxhdGVzO1xufVxuXG4iXX0=

package/lib/esm/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>;