@decaf-ts/mcp-server 0.0.4 → 0.2.0

package/lib/mcp/schemas.cjs

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readmeImprovementSchema = exports.coverageTaskSchema = exports.documentObjectSchema = exports.codeChangeSchema = exports.documentCodeSchema = exports.planFeatureSchema = exports.enumerateCapabilitiesSchema = exports.analyzeRepoSchema = void 0;
+const zod_1 = require("zod");
+exports.analyzeRepoSchema = zod_1.z
+    .object({
+    repoPath: zod_1.z
+        .string()
+        .min(1, "repoPath is required")
+        .describe("Relative or absolute path to the target repository inside this monorepo, e.g. './decoration'."),
+    includeTests: zod_1.z
+        .boolean()
+        .default(true)
+        .describe("If true, analyze the tests directory (if present) to derive expected behaviors."),
+    includeDocs: zod_1.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.");
+exports.enumerateCapabilitiesSchema = zod_1.z
+    .object({
+    repoPath: zod_1.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.");
+exports.planFeatureSchema = zod_1.z
+    .object({
+    feature: zod_1.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: zod_1.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.");
+exports.documentCodeSchema = zod_1.z
+    .object({
+    filePath: zod_1.z.string().min(1, "filePath is required"),
+    promptName: zod_1.z.string().optional(),
+    includePrompt: zod_1.z.boolean().default(true),
+    includeCode: zod_1.z.boolean().default(true),
+    includeMetadata: zod_1.z.boolean().default(true),
+    additionalContext: zod_1.z.string().optional(),
+    encoding: zod_1.z.string().default("utf8"),
+})
+    .strict();
+exports.codeChangeSchema = zod_1.z
+    .object({
+    filePath: zod_1.z.string().min(1, "filePath is required"),
+    patch: zod_1.z.string().min(1, "patch is required"),
+    dryRun: zod_1.z.boolean().default(false),
+    showDiff: zod_1.z.boolean().default(true),
+    diffContext: zod_1.z.number().int().min(0).max(100).default(3),
+    encoding: zod_1.z.string().default("utf8"),
+})
+    .strict();
+const OBJECT_TYPES = [
+    "module",
+    "file",
+    "class",
+    "function",
+    "interface",
+    "decorator",
+    "constant",
+];
+exports.documentObjectSchema = zod_1.z
+    .object({
+    basePath: zod_1.z.string().min(1, "basePath is required"),
+    objectType: zod_1.z.enum(OBJECT_TYPES),
+    targetFile: zod_1.z.string().optional(),
+    includeContent: zod_1.z.boolean().default(false),
+})
+    .strict();
+exports.coverageTaskSchema = zod_1.z
+    .object({
+    basePath: zod_1.z.string().min(1, "basePath is required"),
+    coverage: zod_1.z
+        .number()
+        .min(0)
+        .max(100)
+        .default(90)
+        .describe("Target coverage percentage"),
+    dryRun: zod_1.z.boolean().default(false),
+})
+    .strict();
+exports.readmeImprovementSchema = zod_1.z
+    .object({
+    basePath: zod_1.z.string().min(1, "basePath is required"),
+    includeExamples: zod_1.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/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/mcp/templates/codex-templates.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexPromptTemplates = void 0;
+exports.buildCodexPromptTemplates = buildCodexPromptTemplates;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const workspace_1 = require("./../workspace.cjs");
+exports.codexPromptTemplates = [];
+function buildCodexPromptTemplates() {
+    const root = (0, workspace_1.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 = (0, workspace_1.resolveInWorkspace)(root, path_1.default.join(".codex", "prompts", `${name}.md`));
+                if (!fs_1.default.existsSync(promptPath)) {
+                    throw new Error(`Prompt .codex/prompts/${name}.md not found`);
+                }
+                const text = fs_1.default.readFileSync(promptPath, "utf8");
+                return { text, uri: `codex-prompt:///${name}` };
+            },
+        },
+    ];
+    exports.codexPromptTemplates.splice(0, exports.codexPromptTemplates.length, ...templates);
+    return exports.codexPromptTemplates;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/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/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,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

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[];