@decaf-ts/mcp-server 0.0.3 → 0.2.0

package/lib/mcp/tools/generateMcpModule.cjs

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMcpModuleTool = void 0;
+// New tool: generate-mcp-module
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const zod_1 = require("zod");
+const workspace_1 = require("./../workspace.cjs");
+const code_1 = require("./../code.cjs");
+const scaffoldModule_1 = require("./../validation/scaffoldModule.cjs");
+const generateSchema = zod_1.z.object({
+    repoPath: zod_1.z.string().optional().default("."),
+    moduleName: zod_1.z.string().optional(),
+    includeDocs: zod_1.z.boolean().default(true),
+});
+exports.generateMcpModuleTool = {
+    name: "generate-mcp-module",
+    description: "Generate a minimal MCP module under src/modules/<name> by analyzing a target repository and exporting prompts, resources, templates and tools.",
+    parameters: generateSchema,
+    execute: async (input) => {
+        const args = generateSchema.parse(input);
+        const root = (0, workspace_1.getWorkspaceRoot)();
+        let repoRoot = path_1.default.resolve(process.cwd(), args.repoPath || ".");
+        if (!fs_1.default.existsSync(repoRoot)) {
+            const alt = path_1.default.resolve(process.cwd(), "..", args.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(args.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 inferredName = args.moduleName ?? path_1.default.basename(path_1.default.resolve(repoRoot));
+        const moduleRoot = path_1.default.join(root, "src", "modules", inferredName);
+        // Use existing scaffold to create folders
+        (0, scaffoldModule_1.scaffoldModule)(root, inferredName);
+        // populate prompts: copy markdown prompts from README.md and docs/
+        const promptsDir = path_1.default.join(moduleRoot, "prompts");
+        const resourcesDir = path_1.default.join(moduleRoot, "resources");
+        const templatesDir = path_1.default.join(moduleRoot, "templates");
+        const toolsDir = path_1.default.join(moduleRoot, "tools");
+        // helper to write an index.ts that exports arrays
+        function writeIndex(dir, varName, items) {
+            const p = path_1.default.join(dir, "index.ts");
+            const content = `export const ${varName} = ${items} as const;\n`;
+            fs_1.default.writeFileSync(p, content, { encoding: "utf8" });
+        }
+        // Prompts: create a simple prompt from README and any .md in docs
+        const promptAssets = [];
+        if (args.includeDocs) {
+            const readme = path_1.default.join(repoRoot, "README.md");
+            if (fs_1.default.existsSync(readme)) {
+                const content = fs_1.default.readFileSync(readme, "utf8");
+                const id = "readme";
+                const promptPath = path_1.default.join(promptsDir, `${id}.md`);
+                fs_1.default.writeFileSync(promptPath, content, { encoding: "utf8" });
+                promptAssets.push({
+                    id,
+                    title: "README",
+                    description: "Repository README",
+                    absolutePath: promptPath,
+                    load: () => content,
+                });
+            }
+            const docsDir = path_1.default.join(repoRoot, "docs");
+            if (fs_1.default.existsSync(docsDir) && fs_1.default.statSync(docsDir).isDirectory()) {
+                for (const f of fs_1.default.readdirSync(docsDir)) {
+                    if (!f.endsWith(".md"))
+                        continue;
+                    const content = fs_1.default.readFileSync(path_1.default.join(docsDir, f), "utf8");
+                    const id = path_1.default.parse(f).name;
+                    const promptPath = path_1.default.join(promptsDir, `${id}.md`);
+                    fs_1.default.writeFileSync(promptPath, content, { encoding: "utf8" });
+                    promptAssets.push({
+                        id,
+                        title: id,
+                        description: content.split(/\r?\n/)[0] || "",
+                        absolutePath: promptPath,
+                        load: () => content,
+                    });
+                }
+            }
+        }
+        writeIndex(promptsDir, "prompts", JSON.stringify(promptAssets, null, 2));
+        // Resources: reference the repo root and docs
+        const resourceAssets = [
+            {
+                id: `${inferredName}.repo`,
+                name: `${inferredName} repository`,
+                description: "Source repository",
+                uri: `file://${repoRoot}`,
+                absolutePath: repoRoot,
+            },
+        ];
+        writeIndex(resourcesDir, "resources", JSON.stringify(resourceAssets, null, 2));
+        // Templates: create a placeholder template that references README
+        const templateAssets = [
+            {
+                name: "readme-template",
+                description: "README as guidance",
+                uriTemplate: `file://${path_1.default.join(repoRoot, "README.md")}`,
+                mimeType: "text/markdown",
+            },
+        ];
+        writeIndex(templatesDir, "templates", JSON.stringify(templateAssets, null, 2));
+        // Tools: create a wrapper tool that exposes analyze/enumerate for the module
+        const toolIndexPath = path_1.default.join(toolsDir, "index.ts");
+        const toolContent = `import type { Tool } from 'fastmcp';\nimport { buildAnalyzeRepositoryTool, buildEnumerateCapabilitiesTool, buildPlanFeatureTool } from '../../../mcp/tools/tools';\nexport const tools = [\n  { id: '${inferredName}.analyze', title: 'Analyze ${inferredName}', description: 'Analyze the target repository', tool: buildAnalyzeRepositoryTool() },\n  { id: '${inferredName}.enumerate', title: 'Enumerate capabilities for ${inferredName}', description: 'Enumerate capabilities', tool: buildEnumerateCapabilitiesTool() },\n  { id: '${inferredName}.plan', title: 'Plan features for ${inferredName}', description: 'Plan feature implementation', tool: buildPlanFeatureTool() },\n] as const;\n`;
+        fs_1.default.writeFileSync(toolIndexPath, toolContent, { encoding: "utf8" });
+        // Write module index.ts
+        const moduleIndex = path_1.default.join(moduleRoot, "index.ts");
+        const moduleIndexContent = `import { prompts } from './prompts';\nimport { resources } from './resources';\nimport { templates } from './templates';\nimport { tools } from './tools';\nexport { prompts } from './prompts';\nexport { resources } from './resources';\nexport { templates } from './templates';\nexport { tools } from './tools';\nexport const modulePackage = { name: '${inferredName}', prompts, resources, templates, tools } as const;\n`;
+        fs_1.default.writeFileSync(moduleIndex, moduleIndexContent, { encoding: "utf8" });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        moduleRoot,
+                        inferredName,
+                        analysisSummary: {
+                            files: analysis.files.length,
+                            testFiles: analysis.testFiles.length,
+                        },
+                    }, null, 2),
+                },
+            ],
+        };
+    },
+};
+exports.default = exports.generateMcpModuleTool;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generateMcpModule.js","sourceRoot":"","sources":["../../../src/mcp/tools/generateMcpModule.ts"],"names":[],"mappings":"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","sourcesContent":["// New tool: generate-mcp-module\nimport fs from \"fs\";\nimport path from \"path\";\nimport type { Tool } from \"fastmcp\";\nimport { z } from \"zod\";\nimport { getWorkspaceRoot } from \"../workspace\";\nimport { analyzeRepo } from \"../code\";\nimport { scaffoldModule } from \"../validation/scaffoldModule\";\n\nconst generateSchema = z.object({\n  repoPath: z.string().optional().default(\".\"),\n  moduleName: z.string().optional(),\n  includeDocs: z.boolean().default(true),\n});\n\ntype GenerateArgs = z.infer<typeof generateSchema>;\n\nexport const generateMcpModuleTool: Tool<undefined, typeof generateSchema> = {\n  name: \"generate-mcp-module\",\n  description:\n    \"Generate a minimal MCP module under src/modules/<name> by analyzing a target repository and exporting prompts, resources, templates and tools.\",\n  parameters: generateSchema,\n  execute: async (input) => {\n    const args = generateSchema.parse(input as any);\n    const root = getWorkspaceRoot();\n    let repoRoot = path.resolve(process.cwd(), args.repoPath || \".\");\n    if (!fs.existsSync(repoRoot)) {\n      const alt = path.resolve(process.cwd(), \"..\", args.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(args.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\n    const analysis = analyzeRepo(repoRoot);\n    const inferredName =\n      args.moduleName ?? path.basename(path.resolve(repoRoot));\n    const moduleRoot = path.join(root, \"src\", \"modules\", inferredName);\n\n    // Use existing scaffold to create folders\n    scaffoldModule(root, inferredName);\n\n    // populate prompts: copy markdown prompts from README.md and docs/\n    const promptsDir = path.join(moduleRoot, \"prompts\");\n    const resourcesDir = path.join(moduleRoot, \"resources\");\n    const templatesDir = path.join(moduleRoot, \"templates\");\n    const toolsDir = path.join(moduleRoot, \"tools\");\n\n    // helper to write an index.ts that exports arrays\n    function writeIndex(dir: string, varName: string, items: string) {\n      const p = path.join(dir, \"index.ts\");\n      const content = `export const ${varName} = ${items} as const;\\n`;\n      fs.writeFileSync(p, content, { encoding: \"utf8\" });\n    }\n\n    // Prompts: create a simple prompt from README and any .md in docs\n    const promptAssets: any[] = [];\n    if (args.includeDocs) {\n      const readme = path.join(repoRoot, \"README.md\");\n      if (fs.existsSync(readme)) {\n        const content = fs.readFileSync(readme, \"utf8\");\n        const id = \"readme\";\n        const promptPath = path.join(promptsDir, `${id}.md`);\n        fs.writeFileSync(promptPath, content, { encoding: \"utf8\" });\n        promptAssets.push({\n          id,\n          title: \"README\",\n          description: \"Repository README\",\n          absolutePath: promptPath,\n          load: () => content,\n        });\n      }\n      const docsDir = path.join(repoRoot, \"docs\");\n      if (fs.existsSync(docsDir) && fs.statSync(docsDir).isDirectory()) {\n        for (const f of fs.readdirSync(docsDir)) {\n          if (!f.endsWith(\".md\")) continue;\n          const content = fs.readFileSync(path.join(docsDir, f), \"utf8\");\n          const id = path.parse(f).name;\n          const promptPath = path.join(promptsDir, `${id}.md`);\n          fs.writeFileSync(promptPath, content, { encoding: \"utf8\" });\n          promptAssets.push({\n            id,\n            title: id,\n            description: content.split(/\\r?\\n/)[0] || \"\",\n            absolutePath: promptPath,\n            load: () => content,\n          });\n        }\n      }\n    }\n\n    writeIndex(promptsDir, \"prompts\", JSON.stringify(promptAssets, null, 2));\n\n    // Resources: reference the repo root and docs\n    const resourceAssets = [\n      {\n        id: `${inferredName}.repo`,\n        name: `${inferredName} repository`,\n        description: \"Source repository\",\n        uri: `file://${repoRoot}`,\n        absolutePath: repoRoot,\n      },\n    ];\n    writeIndex(\n      resourcesDir,\n      \"resources\",\n      JSON.stringify(resourceAssets, null, 2)\n    );\n\n    // Templates: create a placeholder template that references README\n    const templateAssets = [\n      {\n        name: \"readme-template\",\n        description: \"README as guidance\",\n        uriTemplate: `file://${path.join(repoRoot, \"README.md\")}`,\n        mimeType: \"text/markdown\",\n      },\n    ];\n    writeIndex(\n      templatesDir,\n      \"templates\",\n      JSON.stringify(templateAssets, null, 2)\n    );\n\n    // Tools: create a wrapper tool that exposes analyze/enumerate for the module\n    const toolIndexPath = path.join(toolsDir, \"index.ts\");\n    const toolContent = `import type { Tool } from 'fastmcp';\\nimport { buildAnalyzeRepositoryTool, buildEnumerateCapabilitiesTool, buildPlanFeatureTool } from '../../../mcp/tools/tools';\\nexport const tools = [\\n  { id: '${inferredName}.analyze', title: 'Analyze ${inferredName}', description: 'Analyze the target repository', tool: buildAnalyzeRepositoryTool() },\\n  { id: '${inferredName}.enumerate', title: 'Enumerate capabilities for ${inferredName}', description: 'Enumerate capabilities', tool: buildEnumerateCapabilitiesTool() },\\n  { id: '${inferredName}.plan', title: 'Plan features for ${inferredName}', description: 'Plan feature implementation', tool: buildPlanFeatureTool() },\\n] as const;\\n`;\n    fs.writeFileSync(toolIndexPath, toolContent, { encoding: \"utf8\" });\n\n    // Write module index.ts\n    const moduleIndex = path.join(moduleRoot, \"index.ts\");\n    const moduleIndexContent = `import { prompts } from './prompts';\\nimport { resources } from './resources';\\nimport { templates } from './templates';\\nimport { tools } from './tools';\\nexport { prompts } from './prompts';\\nexport { resources } from './resources';\\nexport { templates } from './templates';\\nexport { tools } from './tools';\\nexport const modulePackage = { name: '${inferredName}', prompts, resources, templates, tools } as const;\\n`;\n    fs.writeFileSync(moduleIndex, moduleIndexContent, { encoding: \"utf8\" });\n\n    return {\n      content: [\n        {\n          type: \"text\",\n          text: JSON.stringify(\n            {\n              moduleRoot,\n              inferredName,\n              analysisSummary: {\n                files: analysis.files.length,\n                testFiles: analysis.testFiles.length,\n              },\n            },\n            null,\n            2\n          ),\n        },\n      ],\n    };\n  },\n};\n\nexport default generateMcpModuleTool;\n"]}

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

@@ -0,0 +1,9 @@
+import type { Tool } from "fastmcp";
+import { z } from "zod";
+declare const generateSchema: z.ZodObject<{
+    repoPath: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    moduleName: z.ZodOptional<z.ZodString>;
+    includeDocs: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const generateMcpModuleTool: Tool<undefined, typeof generateSchema>;
+export default generateMcpModuleTool;

package/lib/mcp/tools/index.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decoratorTools = exports.tools = exports.decoratorToolList = exports.toolList = void 0;
+const decorator_tools_1 = require("./../decorator-tools.cjs");
+Object.defineProperty(exports, "decoratorTools", { enumerable: true, get: function () { return decorator_tools_1.decoratorTools; } });
+const moduleRegistry_1 = require("./../moduleRegistry.cjs");
+const tools_1 = require("./tools.cjs");
+const codex_tools_1 = require("./codex-tools.cjs");
+__exportStar(require("./tools.cjs"), exports);
+__exportStar(require("./codex-tools.cjs"), exports);
+__exportStar(require("./generateMcpModule.cjs"), exports);
+const codexToolList = [
+    codex_tools_1.documentObjectTool,
+    codex_tools_1.coverageEnforcerTool,
+    codex_tools_1.readmeImprovementTool,
+];
+const moduleToolList = moduleRegistry_1.moduleRegistry.listTools().map((asset) => asset.tool);
+exports.toolList = [...tools_1.toolList, ...codexToolList, ...moduleToolList];
+exports.decoratorToolList = Object.values(decorator_tools_1.decoratorTools);
+const [analyzeRepositoryTool, enumerateCapabilitiesTool, planFeatureTool, documentCodeToolRef, applyCodeChangeToolRef,] = tools_1.toolList;
+exports.tools = {
+    analyzeRepositoryTool,
+    enumerateCapabilitiesTool,
+    planFeatureTool,
+    documentCodeTool: documentCodeToolRef,
+    applyCodeChangeTool: applyCodeChangeToolRef,
+    documentObjectTool: codex_tools_1.documentObjectTool,
+    coverageEnforcerTool: codex_tools_1.coverageEnforcerTool,
+    readmeImprovementTool: codex_tools_1.readmeImprovementTool,
+    ...decorator_tools_1.decoratorTools,
+};
+//# sourceMappingURL=data:application/json;base64,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

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 };