@decaf-ts/mcp-server 0.0.4 → 0.2.0

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

@@ -0,0 +1,321 @@
+import { decoratorTools } from "../decorator-tools";
+export * from "./tools";
+export * from "./codex-tools";
+export * from "./generateMcpModule";
+export declare const toolList: any[];
+export declare const decoratorToolList: ({
+    readonly name: "create-or-update-model";
+    readonly description: "Create or update a validation-ready model class";
+    readonly execute: (args: {
+        filePath: string;
+        className: string;
+        classDecorators?: import("../decorator-tools").DecoratorSpec[];
+        properties: import("../decorator-tools").AttributeSpec[];
+        importsFrom: string;
+        overwrite?: boolean;
+    }) => Promise<{
+        filePath: string;
+    }>;
+} | {
+    readonly name: "add-attribute";
+    readonly description: "Add a decorated attribute to an existing model";
+    readonly execute: (args: {
+        filePath: string;
+        className: string;
+        attribute: import("../decorator-tools").AttributeSpec;
+        importsFrom: string;
+    }) => Promise<{
+        filePath: string;
+    }>;
+} | {
+    readonly name: "remove-attribute";
+    readonly description: "Remove an attribute from a model class";
+    readonly execute: (args: {
+        filePath: string;
+        className: string;
+        attributeName: string;
+    }) => Promise<{
+        filePath: string;
+    }>;
+} | {
+    readonly name: "apply-decorator";
+    readonly description: "Apply a decorator to a class or property";
+    readonly execute: (args: {
+        filePath: string;
+        className: string;
+        target: {
+            kind: "class" | "property";
+            name?: string;
+        };
+        decorator: import("../decorator-tools").DecoratorSpec;
+        importsFrom: string;
+    }) => Promise<{
+        filePath: string;
+    }>;
+} | {
+    readonly name: "remove-decorator";
+    readonly description: "Remove a decorator from a class or property";
+    readonly execute: (args: {
+        filePath: string;
+        className: string;
+        target: {
+            kind: "class" | "property";
+            name?: string;
+        };
+        decoratorName: string;
+    }) => Promise<{
+        filePath: string;
+    }>;
+} | {
+    readonly name: "scaffold-validator";
+    readonly description: "Scaffold a validator class and optional decorator";
+    readonly execute: (args: {
+        validatorsDir: string;
+        decoratorDir?: string;
+        name: string;
+    }) => Promise<{
+        classFile: string;
+        decoratorFile: string | undefined;
+    }>;
+} | {
+    readonly name: "scaffold-serializer";
+    readonly description: "Scaffold a serializer class and optional registry";
+    readonly execute: (args: {
+        dir: string;
+        name: string;
+        registerDir?: string;
+        setDefault?: boolean;
+    }) => Promise<{
+        classFile: string;
+        registerFile: string | undefined;
+    }>;
+} | {
+    readonly name: "scaffold-hashing";
+    readonly description: "Scaffold a hashing function and optional registry";
+    readonly execute: (args: {
+        dir: string;
+        name: string;
+        registerDir?: string;
+        setDefault?: boolean;
+    }) => Promise<{
+        functionFile: string;
+        registerFile: string | undefined;
+    }>;
+})[];
+export declare const tools: {
+    createOrUpdateModelTool: {
+        readonly name: "create-or-update-model";
+        readonly description: "Create or update a validation-ready model class";
+        readonly execute: (args: {
+            filePath: string;
+            className: string;
+            classDecorators?: import("../decorator-tools").DecoratorSpec[];
+            properties: import("../decorator-tools").AttributeSpec[];
+            importsFrom: string;
+            overwrite?: boolean;
+        }) => Promise<{
+            filePath: string;
+        }>;
+    };
+    addAttributeTool: {
+        readonly name: "add-attribute";
+        readonly description: "Add a decorated attribute to an existing model";
+        readonly execute: (args: {
+            filePath: string;
+            className: string;
+            attribute: import("../decorator-tools").AttributeSpec;
+            importsFrom: string;
+        }) => Promise<{
+            filePath: string;
+        }>;
+    };
+    removeAttributeTool: {
+        readonly name: "remove-attribute";
+        readonly description: "Remove an attribute from a model class";
+        readonly execute: (args: {
+            filePath: string;
+            className: string;
+            attributeName: string;
+        }) => Promise<{
+            filePath: string;
+        }>;
+    };
+    applyDecoratorTool: {
+        readonly name: "apply-decorator";
+        readonly description: "Apply a decorator to a class or property";
+        readonly execute: (args: {
+            filePath: string;
+            className: string;
+            target: {
+                kind: "class" | "property";
+                name?: string;
+            };
+            decorator: import("../decorator-tools").DecoratorSpec;
+            importsFrom: string;
+        }) => Promise<{
+            filePath: string;
+        }>;
+    };
+    removeDecoratorTool: {
+        readonly name: "remove-decorator";
+        readonly description: "Remove a decorator from a class or property";
+        readonly execute: (args: {
+            filePath: string;
+            className: string;
+            target: {
+                kind: "class" | "property";
+                name?: string;
+            };
+            decoratorName: string;
+        }) => Promise<{
+            filePath: string;
+        }>;
+    };
+    scaffoldValidatorTool: {
+        readonly name: "scaffold-validator";
+        readonly description: "Scaffold a validator class and optional decorator";
+        readonly execute: (args: {
+            validatorsDir: string;
+            decoratorDir?: string;
+            name: string;
+        }) => Promise<{
+            classFile: string;
+            decoratorFile: string | undefined;
+        }>;
+    };
+    scaffoldSerializerTool: {
+        readonly name: "scaffold-serializer";
+        readonly description: "Scaffold a serializer class and optional registry";
+        readonly execute: (args: {
+            dir: string;
+            name: string;
+            registerDir?: string;
+            setDefault?: boolean;
+        }) => Promise<{
+            classFile: string;
+            registerFile: string | undefined;
+        }>;
+    };
+    scaffoldHashingTool: {
+        readonly name: "scaffold-hashing";
+        readonly description: "Scaffold a hashing function and optional registry";
+        readonly execute: (args: {
+            dir: string;
+            name: string;
+            registerDir?: string;
+            setDefault?: boolean;
+        }) => Promise<{
+            functionFile: string;
+            registerFile: string | undefined;
+        }>;
+    };
+    analyzeRepositoryTool: {
+        annotations?: {
+            streamingHint?: boolean;
+        } & {
+            destructiveHint?: boolean;
+            idempotentHint?: boolean;
+            openWorldHint?: boolean;
+            readOnlyHint?: boolean;
+            title?: string;
+        };
+        canAccess?: ((auth: undefined) => boolean) | undefined;
+        description?: string;
+        execute: (args: any, context: import("fastmcp").Context<undefined>) => Promise<import("fastmcp").AudioContent | import("fastmcp").ContentResult | import("fastmcp").ImageContent | import("fastmcp").ResourceContent | import("fastmcp").ResourceLink | string | import("fastmcp").TextContent | void>;
+        name: string;
+        parameters?: any;
+        timeoutMs?: number;
+    };
+    enumerateCapabilitiesTool: {
+        annotations?: {
+            streamingHint?: boolean;
+        } & {
+            destructiveHint?: boolean;
+            idempotentHint?: boolean;
+            openWorldHint?: boolean;
+            readOnlyHint?: boolean;
+            title?: string;
+        };
+        canAccess?: ((auth: undefined) => boolean) | undefined;
+        description?: string;
+        execute: (args: any, context: import("fastmcp").Context<undefined>) => Promise<import("fastmcp").AudioContent | import("fastmcp").ContentResult | import("fastmcp").ImageContent | import("fastmcp").ResourceContent | import("fastmcp").ResourceLink | string | import("fastmcp").TextContent | void>;
+        name: string;
+        parameters?: any;
+        timeoutMs?: number;
+    };
+    planFeatureTool: {
+        annotations?: {
+            streamingHint?: boolean;
+        } & {
+            destructiveHint?: boolean;
+            idempotentHint?: boolean;
+            openWorldHint?: boolean;
+            readOnlyHint?: boolean;
+            title?: string;
+        };
+        canAccess?: ((auth: undefined) => boolean) | undefined;
+        description?: string;
+        execute: (args: any, context: import("fastmcp").Context<undefined>) => Promise<import("fastmcp").AudioContent | import("fastmcp").ContentResult | import("fastmcp").ImageContent | import("fastmcp").ResourceContent | import("fastmcp").ResourceLink | string | import("fastmcp").TextContent | void>;
+        name: string;
+        parameters?: any;
+        timeoutMs?: number;
+    };
+    documentCodeTool: {
+        annotations?: {
+            streamingHint?: boolean;
+        } & {
+            destructiveHint?: boolean;
+            idempotentHint?: boolean;
+            openWorldHint?: boolean;
+            readOnlyHint?: boolean;
+            title?: string;
+        };
+        canAccess?: ((auth: undefined) => boolean) | undefined;
+        description?: string;
+        execute: (args: any, context: import("fastmcp").Context<undefined>) => Promise<import("fastmcp").AudioContent | import("fastmcp").ContentResult | import("fastmcp").ImageContent | import("fastmcp").ResourceContent | import("fastmcp").ResourceLink | string | import("fastmcp").TextContent | void>;
+        name: string;
+        parameters?: any;
+        timeoutMs?: number;
+    };
+    applyCodeChangeTool: {
+        annotations?: {
+            streamingHint?: boolean;
+        } & {
+            destructiveHint?: boolean;
+            idempotentHint?: boolean;
+            openWorldHint?: boolean;
+            readOnlyHint?: boolean;
+            title?: string;
+        };
+        canAccess?: ((auth: undefined) => boolean) | undefined;
+        description?: string;
+        execute: (args: any, context: import("fastmcp").Context<undefined>) => Promise<import("fastmcp").AudioContent | import("fastmcp").ContentResult | import("fastmcp").ImageContent | import("fastmcp").ResourceContent | import("fastmcp").ResourceLink | string | import("fastmcp").TextContent | void>;
+        name: string;
+        parameters?: any;
+        timeoutMs?: number;
+    };
+    documentObjectTool: import("fastmcp").Tool<undefined, import("zod").ZodObject<{
+        basePath: import("zod").ZodString;
+        objectType: import("zod").ZodEnum<{
+            function: "function";
+            module: "module";
+            file: "file";
+            class: "class";
+            interface: "interface";
+            decorator: "decorator";
+            constant: "constant";
+        }>;
+        targetFile: import("zod").ZodOptional<import("zod").ZodString>;
+        includeContent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strict>>;
+    coverageEnforcerTool: import("fastmcp").Tool<undefined, import("zod").ZodObject<{
+        basePath: import("zod").ZodString;
+        coverage: import("zod").ZodDefault<import("zod").ZodNumber>;
+        dryRun: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strict>>;
+    readmeImprovementTool: import("fastmcp").Tool<undefined, import("zod").ZodObject<{
+        basePath: import("zod").ZodString;
+        includeExamples: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    }, import("zod/v4/core").$strict>>;
+};
+export { decoratorTools };

package/lib/mcp/tools/tools.cjs

@@ -0,0 +1,282 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolList = exports.applyCodeChangeTool = exports.documentCodeTool = void 0;
+exports.buildAnalyzeRepositoryTool = buildAnalyzeRepositoryTool;
+exports.buildEnumerateCapabilitiesTool = buildEnumerateCapabilitiesTool;
+exports.buildPlanFeatureTool = buildPlanFeatureTool;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const diff_1 = require("diff");
+const schemas_1 = require("./../schemas.cjs");
+const code_1 = require("./../code.cjs");
+const utils_1 = require("./../utils.cjs");
+const workspace_1 = require("./../workspace.cjs");
+const prompts_1 = require("./../prompts/prompts.cjs");
+function buildAnalyzeRepositoryTool() {
+    return {
+        name: "analyze-repository",
+        description: "Analyze a local repository's source, tests, and docs to extract exported APIs, decorators, and test mentions.",
+        parameters: schemas_1.analyzeRepoSchema,
+        execute: async (input) => {
+            let repoRoot = path_1.default.resolve(process.cwd(), input.repoPath);
+            if (!fs_1.default.existsSync(repoRoot)) {
+                // try resolving from monorepo root (parent of current cwd)
+                const alt = path_1.default.resolve(process.cwd(), "..", input.repoPath);
+                if (fs_1.default.existsSync(alt))
+                    repoRoot = alt;
+            }
+            if (!fs_1.default.existsSync(repoRoot)) {
+                // if input was absolute and still not found, try ../<basename>
+                const alt2 = path_1.default.resolve(process.cwd(), "..", path_1.default.basename(input.repoPath));
+                if (fs_1.default.existsSync(alt2))
+                    repoRoot = alt2;
+            }
+            if (!fs_1.default.existsSync(repoRoot))
+                throw new Error(`Repository not found at ${repoRoot}`);
+            const result = (0, code_1.analyzeRepo)(repoRoot);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        },
+    };
+}
+function buildEnumerateCapabilitiesTool() {
+    return {
+        name: "enumerate-capabilities",
+        description: "Enumerate developer-facing capabilities of the given repository, inferred from code, tests, and docs.",
+        parameters: schemas_1.enumerateCapabilitiesSchema,
+        execute: async (input) => {
+            let repoRoot = path_1.default.resolve(process.cwd(), input.repoPath);
+            if (!fs_1.default.existsSync(repoRoot)) {
+                const alt = path_1.default.resolve(process.cwd(), "..", input.repoPath);
+                if (fs_1.default.existsSync(alt))
+                    repoRoot = alt;
+            }
+            if (!fs_1.default.existsSync(repoRoot)) {
+                const alt2 = path_1.default.resolve(process.cwd(), "..", path_1.default.basename(input.repoPath));
+                if (fs_1.default.existsSync(alt2))
+                    repoRoot = alt2;
+            }
+            if (!fs_1.default.existsSync(repoRoot))
+                throw new Error(`Repository not found at ${repoRoot}`);
+            const analysis = (0, code_1.analyzeRepo)(repoRoot);
+            const capabilities = (0, utils_1.deriveCapabilities)(analysis);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            capabilities,
+                            analysisSummary: {
+                                files: analysis.files.length,
+                                testFiles: analysis.testFiles.length,
+                                readme: analysis.readme?.title,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        },
+    };
+}
+function buildPlanFeatureTool() {
+    return {
+        name: "plan-feature-implementation",
+        description: "Given a feature request, select appropriate MCP tools (including existing and new ones) and produce an execution plan.",
+        parameters: schemas_1.planFeatureSchema,
+        execute: async (input) => {
+            const steps = [];
+            let i = 1;
+            steps.push({
+                step: i++,
+                action: "Analyze repository to enumerate APIs and decorators",
+                tool: "analyze-repository",
+                arguments: { repoPath: input.repoPath },
+                rationale: "Understand available building blocks.",
+            });
+            steps.push({
+                step: i++,
+                action: "List capabilities expected for developers",
+                tool: "enumerate-capabilities",
+                arguments: { repoPath: input.repoPath },
+                rationale: "Align the plan with supported capabilities.",
+            });
+            // Suggest existing generic tools from mcp-module
+            steps.push({
+                step: i++,
+                action: "Select documentation prompt and gather relevant source file(s)",
+                tool: "document-code",
+                arguments: { filePath: "<target-file>" },
+                rationale: "Provide context and instructions for changes.",
+            });
+            steps.push({
+                step: i++,
+                action: "Apply code changes using unified diff patch",
+                tool: "apply-code-change",
+                arguments: {
+                    filePath: "<target-file>",
+                    patch: "<unified-diff>",
+                    dryRun: true,
+                },
+                rationale: "Validate changes safely before committing.",
+            });
+            steps.push({
+                step: i++,
+                action: "Commit code changes",
+                tool: "apply-code-change",
+                arguments: {
+                    filePath: "<target-file>",
+                    patch: "<unified-diff>",
+                    dryRun: false,
+                },
+                rationale: "Persist the update.",
+            });
+            // If decoration-related terms present, suggest decorator tools
+            if (/decorat|flavour|override|extend|builder/i.test(input.feature)) {
+                steps.unshift({
+                    step: 0,
+                    action: "Use decorator tooling to insert/remove/modify decorators",
+                    tool: "decorator-tools",
+                    arguments: { action: "help" },
+                    rationale: "Leverage specialized utilities for decoration patterns.",
+                });
+                steps.forEach((s, idx) => (s.step = idx + 1));
+            }
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            plan: steps,
+                            notes: "Replace placeholder arguments like <target-file> and <unified-diff> based on the analysis output.",
+                        }, null, 2),
+                    },
+                ],
+            };
+        },
+    };
+}
+exports.documentCodeTool = {
+    annotations: {
+        idempotentHint: true,
+        openWorldHint: false,
+        readOnlyHint: true,
+        title: "Document Source File",
+    },
+    description: "Generate documentation guidance for a file by combining repository prompts with the target source code.",
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute: async (input, _context) => {
+        const args = schemas_1.documentCodeSchema.parse(input);
+        const root = (0, workspace_1.getWorkspaceRoot)();
+        let filePath;
+        try {
+            filePath = (0, workspace_1.resolveInWorkspace)(root, args.filePath);
+        }
+        catch (error) {
+            if (error instanceof workspace_1.WorkspaceError) {
+                return (0, workspace_1.throwUserError)(error.message);
+            }
+            /* istanbul ignore next */
+            throw error;
+        }
+        if (!fs_1.default.existsSync(filePath)) {
+            return (0, workspace_1.throwUserError)(`Cannot document missing file at ${args.filePath}`);
+        }
+        const fileContent = fs_1.default.readFileSync(filePath, {
+            encoding: args.encoding,
+        });
+        const prompts = (0, prompts_1.discoverDocPrompts)(root);
+        if (!prompts.length) {
+            return (0, workspace_1.throwUserError)("No documentation prompts found under .code/prompts or .codex/prompts");
+        }
+        const prompt = (0, prompts_1.selectPrompt)(prompts, args.promptName ?? prompts_1.DEFAULT_PROMPT_NAME);
+        return (0, prompts_1.buildDocumentationPayload)({
+            filePath: args.filePath,
+            fileContent,
+            prompt,
+            includeCode: args.includeCode,
+            includePrompt: args.includePrompt,
+            includeMetadata: args.includeMetadata,
+            additionalContext: args.additionalContext,
+        });
+    },
+    name: "document-code",
+    parameters: schemas_1.documentCodeSchema,
+};
+exports.applyCodeChangeTool = {
+    annotations: {
+        destructiveHint: true,
+        idempotentHint: false,
+        openWorldHint: false,
+        readOnlyHint: false,
+        title: "Apply Code Patch",
+    },
+    description: "Apply a unified diff patch to a workspace file with optional dry-run validation and diff preview.",
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    execute: async (input, _context) => {
+        const args = schemas_1.codeChangeSchema.parse(input);
+        const root = (0, workspace_1.getWorkspaceRoot)();
+        let filePath;
+        try {
+            filePath = (0, workspace_1.resolveInWorkspace)(root, args.filePath);
+        }
+        catch (error) {
+            if (error instanceof workspace_1.WorkspaceError) {
+                return (0, workspace_1.throwUserError)(error.message);
+            }
+            throw error;
+        }
+        const original = fs_1.default.existsSync(filePath)
+            ? fs_1.default.readFileSync(filePath, args.encoding)
+            : "";
+        let patched;
+        try {
+            patched = (0, diff_1.applyPatch)(original, args.patch);
+        }
+        catch (error) {
+            return (0, workspace_1.throwUserError)(`Failed to apply provided patch to ${args.filePath}: ${error instanceof Error ? error.message : error}`);
+        }
+        /* istanbul ignore next */
+        if (patched === false) {
+            return (0, workspace_1.throwUserError)(`Failed to apply provided patch to ${args.filePath}`);
+        }
+        if (!args.dryRun) {
+            fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+            fs_1.default.writeFileSync(filePath, patched, {
+                encoding: args.encoding,
+            });
+        }
+        if (!args.showDiff) {
+            return `Patch ${args.dryRun ? "validated" : "applied"} for ${args.filePath}`;
+        }
+        const preview = (0, diff_1.createTwoFilesPatch)(args.filePath, args.filePath, original, patched, undefined, undefined, { context: args.diffContext });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Patch ${args.dryRun ? "validated" : "applied"} for ${args.filePath}`,
+                },
+                {
+                    type: "text",
+                    text: ["```diff", preview.trim(), "```"].join("\n"),
+                },
+            ],
+        };
+    },
+    name: "apply-code-change",
+    parameters: schemas_1.codeChangeSchema,
+};
+const analyticTools = [
+    buildAnalyzeRepositoryTool(),
+    buildEnumerateCapabilitiesTool(),
+    buildPlanFeatureTool(),
+];
+exports.toolList = [
+    ...analyticTools,
+    exports.documentCodeTool,
+    exports.applyCodeChangeTool,
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tools.js","sourceRoot":"","sources":["../../../src/mcp/tools/tools.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\nimport { ContentResult, Tool } from \"fastmcp\";\nimport { applyPatch, createTwoFilesPatch } from \"diff\";\nimport {\n  analyzeRepoSchema,\n  codeChangeSchema,\n  documentCodeSchema,\n  enumerateCapabilitiesSchema,\n  planFeatureSchema,\n} from \"../schemas\";\nimport { analyzeRepo } from \"../code\";\nimport { deriveCapabilities } from \"../utils\";\nimport {\n  getWorkspaceRoot,\n  resolveInWorkspace,\n  throwUserError,\n  WorkspaceError,\n} from \"../workspace\";\nimport {\n  buildDocumentationPayload,\n  DEFAULT_PROMPT_NAME,\n  discoverDocPrompts,\n  selectPrompt,\n} from \"../prompts/prompts\";\nimport type { ApplyCodeChangeArgs, DocumentCodeArgs } from \"../types\";\nimport { generateMcpModuleTool } from \"./generateMcpModule\";\n\nexport function buildAnalyzeRepositoryTool(): Tool<\n  undefined,\n  typeof analyzeRepoSchema\n> {\n  return {\n    name: \"analyze-repository\",\n    description:\n      \"Analyze a local repository's source, tests, and docs to extract exported APIs, decorators, and test mentions.\",\n    parameters: analyzeRepoSchema,\n    execute: async (input) => {\n      let repoRoot = path.resolve(process.cwd(), input.repoPath);\n      if (!fs.existsSync(repoRoot)) {\n        // try resolving from monorepo root (parent of current cwd)\n        const alt = path.resolve(process.cwd(), \"..\", input.repoPath);\n        if (fs.existsSync(alt)) repoRoot = alt;\n      }\n      if (!fs.existsSync(repoRoot)) {\n        // if input was absolute and still not found, try ../<basename>\n        const alt2 = path.resolve(\n          process.cwd(),\n          \"..\",\n          path.basename(input.repoPath)\n        );\n        if (fs.existsSync(alt2)) repoRoot = alt2;\n      }\n      if (!fs.existsSync(repoRoot))\n        throw new Error(`Repository not found at ${repoRoot}`);\n      const result = analyzeRepo(repoRoot);\n      return {\n        content: [{ type: \"text\", text: JSON.stringify(result, null, 2) }],\n      };\n    },\n  };\n}\n\nexport function buildEnumerateCapabilitiesTool(): Tool<\n  undefined,\n  typeof enumerateCapabilitiesSchema\n> {\n  return {\n    name: \"enumerate-capabilities\",\n    description:\n      \"Enumerate developer-facing capabilities of the given repository, inferred from code, tests, and docs.\",\n    parameters: enumerateCapabilitiesSchema,\n    execute: async (input) => {\n      let repoRoot = path.resolve(process.cwd(), input.repoPath);\n      if (!fs.existsSync(repoRoot)) {\n        const alt = path.resolve(process.cwd(), \"..\", input.repoPath);\n        if (fs.existsSync(alt)) repoRoot = alt;\n      }\n      if (!fs.existsSync(repoRoot)) {\n        const alt2 = path.resolve(\n          process.cwd(),\n          \"..\",\n          path.basename(input.repoPath)\n        );\n        if (fs.existsSync(alt2)) repoRoot = alt2;\n      }\n      if (!fs.existsSync(repoRoot))\n        throw new Error(`Repository not found at ${repoRoot}`);\n      const analysis = analyzeRepo(repoRoot);\n      const capabilities = deriveCapabilities(analysis);\n      return {\n        content: [\n          {\n            type: \"text\",\n            text: JSON.stringify(\n              {\n                capabilities,\n                analysisSummary: {\n                  files: analysis.files.length,\n                  testFiles: analysis.testFiles.length,\n                  readme: analysis.readme?.title,\n                },\n              },\n              null,\n              2\n            ),\n          },\n        ],\n      };\n    },\n  };\n}\n\nexport function buildPlanFeatureTool(): Tool<\n  undefined,\n  typeof planFeatureSchema\n> {\n  return {\n    name: \"plan-feature-implementation\",\n    description:\n      \"Given a feature request, select appropriate MCP tools (including existing and new ones) and produce an execution plan.\",\n    parameters: planFeatureSchema,\n    execute: async (input) => {\n      const steps: Array<{\n        step: number;\n        action: string;\n        tool?: string;\n        arguments?: Record<string, any>;\n        rationale: string;\n      }> = [];\n      let i = 1;\n      steps.push({\n        step: i++,\n        action: \"Analyze repository to enumerate APIs and decorators\",\n        tool: \"analyze-repository\",\n        arguments: { repoPath: input.repoPath },\n        rationale: \"Understand available building blocks.\",\n      });\n      steps.push({\n        step: i++,\n        action: \"List capabilities expected for developers\",\n        tool: \"enumerate-capabilities\",\n        arguments: { repoPath: input.repoPath },\n        rationale: \"Align the plan with supported capabilities.\",\n      });\n      // Suggest existing generic tools from mcp-module\n      steps.push({\n        step: i++,\n        action:\n          \"Select documentation prompt and gather relevant source file(s)\",\n        tool: \"document-code\",\n        arguments: { filePath: \"<target-file>\" },\n        rationale: \"Provide context and instructions for changes.\",\n      });\n      steps.push({\n        step: i++,\n        action: \"Apply code changes using unified diff patch\",\n        tool: \"apply-code-change\",\n        arguments: {\n          filePath: \"<target-file>\",\n          patch: \"<unified-diff>\",\n          dryRun: true,\n        },\n        rationale: \"Validate changes safely before committing.\",\n      });\n      steps.push({\n        step: i++,\n        action: \"Commit code changes\",\n        tool: \"apply-code-change\",\n        arguments: {\n          filePath: \"<target-file>\",\n          patch: \"<unified-diff>\",\n          dryRun: false,\n        },\n        rationale: \"Persist the update.\",\n      });\n      // If decoration-related terms present, suggest decorator tools\n      if (/decorat|flavour|override|extend|builder/i.test(input.feature)) {\n        steps.unshift({\n          step: 0,\n          action: \"Use decorator tooling to insert/remove/modify decorators\",\n          tool: \"decorator-tools\",\n          arguments: { action: \"help\" },\n          rationale: \"Leverage specialized utilities for decoration patterns.\",\n        });\n        steps.forEach((s, idx) => (s.step = idx + 1));\n      }\n      return {\n        content: [\n          {\n            type: \"text\",\n            text: JSON.stringify(\n              {\n                plan: steps,\n                notes:\n                  \"Replace placeholder arguments like <target-file> and <unified-diff> based on the analysis output.\",\n              },\n              null,\n              2\n            ),\n          },\n        ],\n      };\n    },\n  };\n}\n\nexport const documentCodeTool: Tool<undefined, typeof documentCodeSchema> = {\n  annotations: {\n    idempotentHint: true,\n    openWorldHint: false,\n    readOnlyHint: true,\n    title: \"Document Source File\",\n  },\n  description:\n    \"Generate documentation guidance for a file by combining repository prompts with the target source code.\",\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  execute: async (input, _context): Promise<ContentResult> => {\n    const args = documentCodeSchema.parse(input as DocumentCodeArgs);\n    const root = getWorkspaceRoot();\n    let filePath: string;\n    try {\n      filePath = resolveInWorkspace(root, args.filePath);\n    } catch (error) {\n      if (error instanceof WorkspaceError) {\n        return throwUserError(error.message);\n      }\n      /* istanbul ignore next */\n      throw error;\n    }\n\n    if (!fs.existsSync(filePath)) {\n      return throwUserError(`Cannot document missing file at ${args.filePath}`);\n    }\n\n    const fileContent = fs.readFileSync(filePath, {\n      encoding: args.encoding as BufferEncoding,\n    });\n    const prompts = discoverDocPrompts(root);\n\n    if (!prompts.length) {\n      return throwUserError(\n        \"No documentation prompts found under .code/prompts or .codex/prompts\"\n      );\n    }\n\n    const prompt = selectPrompt(\n      prompts,\n      args.promptName ?? DEFAULT_PROMPT_NAME\n    );\n\n    return buildDocumentationPayload({\n      filePath: args.filePath,\n      fileContent,\n      prompt,\n      includeCode: args.includeCode,\n      includePrompt: args.includePrompt,\n      includeMetadata: args.includeMetadata,\n      additionalContext: args.additionalContext,\n    });\n  },\n  name: \"document-code\",\n  parameters: documentCodeSchema,\n};\n\nexport const applyCodeChangeTool: Tool<undefined, typeof codeChangeSchema> = {\n  annotations: {\n    destructiveHint: true,\n    idempotentHint: false,\n    openWorldHint: false,\n    readOnlyHint: false,\n    title: \"Apply Code Patch\",\n  },\n  description:\n    \"Apply a unified diff patch to a workspace file with optional dry-run validation and diff preview.\",\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  execute: async (input, _context): Promise<string | ContentResult> => {\n    const args = codeChangeSchema.parse(input as ApplyCodeChangeArgs);\n    const root = getWorkspaceRoot();\n    let filePath: string;\n    try {\n      filePath = resolveInWorkspace(root, args.filePath);\n    } catch (error) {\n      if (error instanceof WorkspaceError) {\n        return throwUserError(error.message);\n      }\n      throw error;\n    }\n\n    const original = fs.existsSync(filePath)\n      ? fs.readFileSync(filePath, args.encoding as BufferEncoding)\n      : \"\";\n\n    let patched: string | false;\n    try {\n      patched = applyPatch(original, args.patch);\n    } catch (error) {\n      return throwUserError(\n        `Failed to apply provided patch to ${args.filePath}: ${error instanceof Error ? error.message : error}`\n      );\n    }\n    /* istanbul ignore next */\n    if (patched === false) {\n      return throwUserError(\n        `Failed to apply provided patch to ${args.filePath}`\n      );\n    }\n\n    if (!args.dryRun) {\n      fs.mkdirSync(path.dirname(filePath), { recursive: true });\n      fs.writeFileSync(filePath, patched, {\n        encoding: args.encoding as BufferEncoding,\n      });\n    }\n\n    if (!args.showDiff) {\n      return `Patch ${args.dryRun ? \"validated\" : \"applied\"} for ${args.filePath}`;\n    }\n\n    const preview = createTwoFilesPatch(\n      args.filePath,\n      args.filePath,\n      original,\n      patched,\n      undefined,\n      undefined,\n      { context: args.diffContext }\n    );\n\n    return {\n      content: [\n        {\n          type: \"text\",\n          text: `Patch ${args.dryRun ? \"validated\" : \"applied\"} for ${args.filePath}`,\n        },\n        {\n          type: \"text\",\n          text: [\"```diff\", preview.trim(), \"```\"].join(\"\\n\"),\n        },\n      ],\n    } satisfies ContentResult;\n  },\n  name: \"apply-code-change\",\n  parameters: codeChangeSchema,\n};\n\ntype AnyTool = Tool<undefined, any>;\n\nconst analyticTools: AnyTool[] = [\n  buildAnalyzeRepositoryTool(),\n  buildEnumerateCapabilitiesTool(),\n  buildPlanFeatureTool(),\n];\n\nexport const toolList: AnyTool[] = [\n  ...analyticTools,\n  documentCodeTool,\n  applyCodeChangeTool,\n];\n"]}

package/lib/mcp/tools/tools.d.ts

@@ -0,0 +1,10 @@
+import { Tool } from "fastmcp";
+import { analyzeRepoSchema, codeChangeSchema, documentCodeSchema, enumerateCapabilitiesSchema, planFeatureSchema } from "../schemas";
+export declare function buildAnalyzeRepositoryTool(): Tool<undefined, typeof analyzeRepoSchema>;
+export declare function buildEnumerateCapabilitiesTool(): Tool<undefined, typeof enumerateCapabilitiesSchema>;
+export declare function buildPlanFeatureTool(): Tool<undefined, typeof planFeatureSchema>;
+export declare const documentCodeTool: Tool<undefined, typeof documentCodeSchema>;
+export declare const applyCodeChangeTool: Tool<undefined, typeof codeChangeSchema>;
+type AnyTool = Tool<undefined, any>;
+export declare const toolList: AnyTool[];
+export {};

package/lib/mcp/types.cjs

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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