ultimate-unreal-engine-mcp 0.1.0

package/dist/tools/config/index.js

@@ -0,0 +1,288 @@
+// src/tools/config/index.ts
+// Registers UE config file tools on the MCP server.
+// All handlers validated with validatePath() and wrapped with withKnownIssues().
+// No console.log — all logging uses stderr via console.error (see logger.ts).
+// Backup (.bak) is created before any write operation.
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { z } from 'zod';
+import { withKnownIssues } from '../known-issues/middleware.js';
+import { parseIni, setIniValue } from '../../parsers/ini-parser.js';
+import { parseUproject, parseUplugin } from '../../parsers/uproject-parser.js';
+import { validatePath } from '../../utils/path-guard.js';
+import { PROJECT_ROOT } from '../../config.js';
+/**
+ * Register UE config file tools on the MCP server.
+ *
+ * Tools registered:
+ *   ue_read_config    — Read a section/key from a UE .ini config file
+ *   ue_write_config   — Write a key to a UE .ini config file (with .bak backup)
+ *   ue_read_uproject  — Parse a .uproject file
+ *   ue_list_plugins   — List plugins enabled in a .uproject file
+ *
+ * @param server  The McpServer instance to register tools on.
+ */
+export function registerConfigTools(server) {
+    // --------------------------------------------------------------------------
+    // ue_read_config
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_read_config', {
+        title: 'Read UE Config',
+        description: 'Read a value or section from a UE .ini configuration file (DefaultEngine.ini, DefaultGame.ini, etc.).',
+        inputSchema: z.object({
+            config_file: z.string().describe('Absolute path to the .ini config file'),
+            section: z.string().optional().describe('The [Section] to read (optional — omit to list all sections)'),
+            key: z.string().optional().describe('The key to read within the section (optional — omit to list all keys in section)'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+        },
+    }, withKnownIssues('ue_read_config', async (args) => {
+        // 1. Validate path — throws on traversal; withKnownIssues catches → isError
+        const resolvedPath = validatePath(args.config_file, PROJECT_ROOT);
+        // 2. Read file — ENOENT returns isError (not a throw caught by middleware)
+        let content;
+        try {
+            content = await fs.readFile(resolvedPath, 'utf8');
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === 'ENOENT') {
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: `File not found: ${resolvedPath}` }],
+                };
+            }
+            throw err; // unexpected — let withKnownIssues catch it
+        }
+        // 3. Parse
+        const parsed = parseIni(content);
+        const fileName = path.basename(resolvedPath);
+        // 4. No section: list all section names
+        if (!args.section) {
+            const sections = Object.keys(parsed);
+            const text = sections.length > 0
+                ? `Sections in ${fileName}:\n${sections.join('\n')}`
+                : `No sections found in ${fileName}`;
+            return { content: [{ type: 'text', text }] };
+        }
+        // 5. Section but no key: return all keys and values in section
+        if (!args.key) {
+            const section = parsed[args.section];
+            if (!section) {
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: `Section '[${args.section}]' not found in ${fileName}` }],
+                };
+            }
+            const lines = Object.entries(section).map(([k, vals]) => `${k}=${vals.join(', ')}`);
+            const text = lines.length > 0
+                ? `[${args.section}] in ${fileName}:\n${lines.join('\n')}`
+                : `[${args.section}] exists but has no keys in ${fileName}`;
+            return { content: [{ type: 'text', text }] };
+        }
+        // 6. Section and key: return value(s)
+        const section = parsed[args.section];
+        if (!section) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: `Section '[${args.section}]' not found in ${fileName}` }],
+            };
+        }
+        const values = section[args.key];
+        if (!values || values.length === 0) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: `Key '${args.key}' not found in section '[${args.section}]' in ${fileName}` }],
+            };
+        }
+        const text = values.length === 1
+            ? values[0]
+            : values.join('\n');
+        return { content: [{ type: 'text', text }] };
+    }));
+    // --------------------------------------------------------------------------
+    // ue_write_config
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_write_config', {
+        title: 'Write UE Config',
+        description: 'Write a key=value pair to a UE .ini configuration file. Creates the section and key if they do not exist. ' +
+            'Do not write to Saved/Config/ — those files are managed by the editor and will be overwritten at next launch.',
+        inputSchema: z.object({
+            config_file: z.string().describe('Absolute path to the .ini config file'),
+            section: z.string().describe('The [Section] to write to'),
+            key: z.string().describe('The key to set'),
+            value: z.string().describe('The value to write'),
+        }),
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+        },
+    }, withKnownIssues('ue_write_config', async (args) => {
+        // 1. Validate path — throws on traversal
+        const resolvedPath = validatePath(args.config_file, PROJECT_ROOT);
+        // 2. Read existing content — ENOENT → empty string (new file)
+        let currentContent = '';
+        try {
+            currentContent = await fs.readFile(resolvedPath, 'utf8');
+        }
+        catch (err) {
+            const e = err;
+            if (e.code !== 'ENOENT')
+                throw err;
+            // ENOENT: new file — proceed with empty content
+        }
+        // 3. Backup before modifying — skip if new file (ENOENT on copy)
+        try {
+            await fs.copyFile(resolvedPath, resolvedPath + '.bak');
+        }
+        catch (err) {
+            const e = err;
+            if (e.code !== 'ENOENT')
+                throw err;
+            // ENOENT: new file, nothing to back up — continue
+        }
+        // 4. Ensure parent directory exists for new files
+        await fs.mkdir(path.dirname(resolvedPath), { recursive: true });
+        // 5. Compute new content and write
+        const newContent = setIniValue(currentContent, args.section, args.key, args.value);
+        await fs.writeFile(resolvedPath, newContent, 'utf8');
+        return {
+            content: [{ type: 'text', text: `Written: [${args.section}] ${args.key}=${args.value}` }],
+        };
+    }));
+    // --------------------------------------------------------------------------
+    // ue_read_uproject
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_read_uproject', {
+        title: 'Read UE Project File',
+        description: 'Parse a .uproject JSON file and return its contents (engine version, plugins, modules, etc.).',
+        inputSchema: z.object({
+            uproject_path: z.string().describe('Absolute path to the .uproject file'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+        },
+    }, withKnownIssues('ue_read_uproject', async (args) => {
+        // 1. Validate path
+        const resolvedPath = validatePath(args.uproject_path, PROJECT_ROOT);
+        // 2. Read file
+        let content;
+        try {
+            content = await fs.readFile(resolvedPath, 'utf8');
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === 'ENOENT') {
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: `File not found: ${resolvedPath}` }],
+                };
+            }
+            throw err;
+        }
+        // 3. Parse with Zod-validated parser
+        const result = parseUproject(content);
+        if (!result.success) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: result.error }],
+            };
+        }
+        // 4. Format response
+        const data = result.data;
+        const engineAssoc = data.EngineAssociation ?? 'not specified';
+        const modules = data.Modules ?? [];
+        const plugins = data.Plugins ?? [];
+        const moduleList = modules.length > 0
+            ? modules.map((m) => `${m.Name} [${m.Type}]`).join(', ')
+            : 'none';
+        const pluginList = plugins.length > 0
+            ? plugins.map((p) => `${p.Name} [${p.Enabled ? 'enabled' : 'disabled'}]`).join(', ')
+            : 'none';
+        const text = [
+            `Engine Association: ${engineAssoc}`,
+            `Modules (${modules.length}): ${moduleList}`,
+            `Plugins (${plugins.length}): ${pluginList}`,
+        ].join('\n');
+        return { content: [{ type: 'text', text }] };
+    }));
+    // --------------------------------------------------------------------------
+    // ue_list_plugins
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_list_plugins', {
+        title: 'List UE Plugins',
+        description: 'List all plugins enabled in a .uproject file, including engine plugins and project-local plugins.',
+        inputSchema: z.object({
+            uproject_path: z.string().describe('Absolute path to the .uproject file'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+        },
+    }, withKnownIssues('ue_list_plugins', async (args) => {
+        // 1. Validate path
+        const resolvedPath = validatePath(args.uproject_path, PROJECT_ROOT);
+        // 2. Read file
+        let content;
+        try {
+            content = await fs.readFile(resolvedPath, 'utf8');
+        }
+        catch (err) {
+            const e = err;
+            if (e.code === 'ENOENT') {
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: `File not found: ${resolvedPath}` }],
+                };
+            }
+            throw err;
+        }
+        // 3. Parse .uproject
+        const result = parseUproject(content);
+        if (!result.success) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: result.error }],
+            };
+        }
+        // 4. For each plugin, try to resolve its .uplugin file
+        const plugins = result.data.Plugins ?? [];
+        const uprojectDir = path.dirname(resolvedPath);
+        const lines = [];
+        for (const plugin of plugins) {
+            const status = plugin.Enabled ? 'enabled' : 'disabled';
+            const upluginPath = path.join(uprojectDir, 'Plugins', plugin.Name, `${plugin.Name}.uplugin`);
+            let depInfo;
+            try {
+                const upluginContent = await fs.readFile(upluginPath, 'utf8');
+                const upluginResult = parseUplugin(upluginContent);
+                if (upluginResult.success) {
+                    const deps = upluginResult.data.Plugins ?? [];
+                    depInfo = deps.length > 0
+                        ? `dependencies: [${deps.map((d) => d.Name).join(', ')}]`
+                        : 'dependencies: none';
+                }
+                else {
+                    depInfo = `dependencies: unknown (parse error: ${upluginResult.error})`;
+                }
+            }
+            catch (err) {
+                const e = err;
+                if (e.code === 'ENOENT') {
+                    depInfo = 'Engine plugin — .uplugin not accessible without engine root';
+                }
+                else {
+                    throw err;
+                }
+            }
+            lines.push(`[${status}] ${plugin.Name} — ${depInfo}`);
+        }
+        const text = lines.length > 0
+            ? lines.join('\n')
+            : 'No plugins found in .uproject file';
+        return { content: [{ type: 'text', text }] };
+    }));
+}

package/dist/tools/cpp/index.js

@@ -0,0 +1,305 @@
+// src/tools/cpp/index.ts
+// Registers real C++ parsing and analysis tools on the MCP server.
+// Implements CPP-01 through CPP-04 using cpp-parser.ts and cpp-class-index.ts.
+// Implements GEN-01 through GEN-08 using class-generator.ts and file-modifier.ts.
+//
+// All handlers:
+//   - Wrapped with withKnownIssues() for known-issue pre-check and exception catching
+//   - File path args validated via validatePath() before any fs operation (T-04-06, T-05-09, T-05-10)
+//   - Use console.error only (never console.log — stdout safety)
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { z } from 'zod';
+import { withKnownIssues } from '../known-issues/middleware.js';
+import { parseCppFile } from '../../parsers/cpp-parser.js';
+import { buildIndex } from '../../parsers/cpp-class-index.js';
+import { validatePath } from '../../utils/path-guard.js';
+import { PROJECT_ROOT } from '../../config.js';
+import { generateClass } from '../../generators/class-generator.js';
+import { addProperty, addFunction, addInclude } from '../../generators/file-modifier.js';
+import { validateUhtRules } from '../../generators/uht-validator.js';
+/**
+ * ue_read_cpp_class handler — reads and parses a UE C++ header file.
+ * CPP-01: Extracts UCLASS, UPROPERTY, UFUNCTION declarations with specifiers and meta.
+ */
+export async function handleReadCppClass(args) {
+    const safePath = validatePath(args.file_path, PROJECT_ROOT);
+    const content = await fs.readFile(safePath, 'utf8');
+    const result = parseCppFile(content);
+    if (!result.success) {
+        return { isError: true, content: [{ type: 'text', text: `Parse error: ${result.error}` }] };
+    }
+    return { content: [{ type: 'text', text: JSON.stringify(result.data, null, 2) }] };
+}
+/**
+ * ue_get_class_hierarchy handler — returns the inheritance chain for a UE class.
+ * CPP-02: Walks parentClass links in the project class index.
+ */
+export async function handleGetClassHierarchy(args) {
+    const indexResult = await buildIndex(PROJECT_ROOT);
+    if (!indexResult.success) {
+        return { isError: true, content: [{ type: 'text', text: `Index error: ${indexResult.error}` }] };
+    }
+    const chain = indexResult.index.getClassHierarchy(args.class_name);
+    return { content: [{ type: 'text', text: JSON.stringify({ className: args.class_name, chain }, null, 2) }] };
+}
+/**
+ * ue_trace_includes handler — returns the direct #include list from a header file.
+ * CPP-03: Reads the file directly and returns its parsed include list.
+ */
+export async function handleTraceIncludes(args) {
+    const safePath = validatePath(args.file_path, PROJECT_ROOT);
+    const content = await fs.readFile(safePath, 'utf8');
+    const parseResult = parseCppFile(content);
+    if (!parseResult.success) {
+        return { isError: true, content: [{ type: 'text', text: `Parse error: ${parseResult.error}` }] };
+    }
+    return { content: [{ type: 'text', text: JSON.stringify({ filePath: safePath, includes: parseResult.data.includes }, null, 2) }] };
+}
+/**
+ * ue_find_class_file handler — locates header and source files for a UE class.
+ * CPP-04: Searches the project class index for the given class name.
+ */
+export async function handleFindClassFile(args) {
+    const indexResult = await buildIndex(PROJECT_ROOT);
+    if (!indexResult.success) {
+        return { isError: true, content: [{ type: 'text', text: `Index error: ${indexResult.error}` }] };
+    }
+    const found = indexResult.index.findClassFile(args.class_name);
+    if (!found) {
+        return { content: [{ type: 'text', text: `Class "${args.class_name}" not found in Source/ directory` }] };
+    }
+    return { content: [{ type: 'text', text: JSON.stringify(found, null, 2) }] };
+}
+/**
+ * ue_generate_class handler — generates a new UE C++ class file pair (.h + .cpp).
+ * GEN-01 through GEN-04, GEN-08: Creates class files for Actor, Component, GameMode,
+ * Interface, etc. with correct UHT macros. Validates with UHT rules before writing.
+ * T-05-09: Validates output_dir and final file paths against PROJECT_ROOT.
+ */
+export async function handleGenerateClass(args) {
+    const safeDir = validatePath(args.output_dir, PROJECT_ROOT);
+    // Validate class_type is a known ClassType
+    const VALID_TYPES = ['Actor', 'ActorComponent', 'SceneComponent', 'GameMode', 'GameState', 'PlayerState', 'PlayerController', 'Interface'];
+    if (!VALID_TYPES.includes(args.class_type)) {
+        return { isError: true, content: [{ type: 'text', text: `Unknown class_type: "${args.class_type}". Valid: ${VALID_TYPES.join(', ')}` }] };
+    }
+    const generated = generateClass({
+        classType: args.class_type,
+        className: args.class_name,
+        moduleName: args.module_name,
+        parentClass: args.parent_class,
+    });
+    // UHT pre-validation (GEN-08): validate header before writing to disk
+    const validation = validateUhtRules(generated.header);
+    if (!validation.valid) {
+        return { isError: true, content: [{ type: 'text', text: `UHT validation failed:\n${validation.errors.join('\n')}` }] };
+    }
+    const headerPath = path.join(safeDir, generated.headerFileName);
+    const cppPath = path.join(safeDir, generated.cppFileName);
+    // Re-validate final paths are within project root (T-05-09)
+    validatePath(headerPath, PROJECT_ROOT);
+    validatePath(cppPath, PROJECT_ROOT);
+    await fs.writeFile(headerPath, generated.header, 'utf8');
+    await fs.writeFile(cppPath, generated.cpp, 'utf8');
+    const HOT_RELOAD_WARNING = '\n\nNote: Restart the Unreal Editor (or recompile) before creating Blueprint subclasses of the new class. Hot Reload does not register new C++ classes.';
+    return {
+        content: [{
+                type: 'text',
+                text: `Generated ${args.class_type} class "${generated.headerFileName.replace('.h', '')}"\nHeader: ${headerPath}\nCpp: ${cppPath}${HOT_RELOAD_WARNING}`,
+            }],
+    };
+}
+/**
+ * ue_add_property handler — adds a UPROPERTY declaration to an existing .h file.
+ * GEN-05: Reads file, calls addProperty (which calls validateUhtRules internally), writes result.
+ * T-05-10: Validates file_path against PROJECT_ROOT before reading/writing.
+ */
+export async function handleAddProperty(args) {
+    const safePath = validatePath(args.file_path, PROJECT_ROOT);
+    const content = await fs.readFile(safePath, 'utf8');
+    const result = addProperty(content, args.class_name, {
+        specifiers: args.specifiers,
+        type: args.type,
+        name: args.name,
+        defaultValue: args.default_value,
+    });
+    if (!result.success) {
+        return { isError: true, content: [{ type: 'text', text: result.error }] };
+    }
+    await fs.writeFile(safePath, result.content, 'utf8');
+    return { content: [{ type: 'text', text: `Added UPROPERTY ${args.name} to class ${args.class_name} in ${safePath}` }] };
+}
+/**
+ * ue_add_function handler — adds a UFUNCTION declaration to an existing .h file.
+ * GEN-06: Reads file, calls addFunction (which calls validateUhtRules internally), writes result.
+ * T-05-10: Validates file_path against PROJECT_ROOT before reading/writing.
+ */
+export async function handleAddFunction(args) {
+    const safePath = validatePath(args.file_path, PROJECT_ROOT);
+    const content = await fs.readFile(safePath, 'utf8');
+    const result = addFunction(content, args.class_name, {
+        specifiers: args.specifiers,
+        returnType: args.return_type,
+        name: args.name,
+        params: args.params,
+        isConst: args.is_const,
+    });
+    if (!result.success) {
+        return { isError: true, content: [{ type: 'text', text: result.error }] };
+    }
+    await fs.writeFile(safePath, result.content, 'utf8');
+    return { content: [{ type: 'text', text: `Added UFUNCTION ${args.name} to class ${args.class_name} in ${safePath}` }] };
+}
+/**
+ * ue_add_include handler — adds an #include directive to an existing .h or .cpp file.
+ * GEN-07: Reads file, calls addInclude (idempotent, which calls validateUhtRules), writes result.
+ * T-05-10: Validates file_path against PROJECT_ROOT before reading/writing.
+ */
+export async function handleAddInclude(args) {
+    const safePath = validatePath(args.file_path, PROJECT_ROOT);
+    const content = await fs.readFile(safePath, 'utf8');
+    const result = addInclude(content, args.include_path);
+    if (!result.success) {
+        return { isError: true, content: [{ type: 'text', text: result.error }] };
+    }
+    await fs.writeFile(safePath, result.content, 'utf8');
+    return { content: [{ type: 'text', text: `Added include "${args.include_path}" to ${safePath}` }] };
+}
+// ---------------------------------------------------------------------------
+// Tool registration
+// ---------------------------------------------------------------------------
+/**
+ * Register C++ analysis and generation tools on the MCP server.
+ *
+ * Tools registered (real implementations — CPP-01 through CPP-04, GEN-01 through GEN-08):
+ *   ue_read_cpp_class      — Read and parse a UE C++ header file
+ *   ue_get_class_hierarchy — Get inheritance hierarchy for a UE class
+ *   ue_trace_includes      — Trace include chain for a header file
+ *   ue_find_class_file     — Locate the header and source files for a UE class name
+ *   ue_generate_class      — Generate a new UE C++ class file pair (.h + .cpp)
+ *   ue_add_property        — Add a UPROPERTY declaration to an existing .h file
+ *   ue_add_function        — Add a UFUNCTION declaration to an existing .h file
+ *   ue_add_include         — Add an #include directive to an existing .h or .cpp file
+ *
+ * @param server  The McpServer instance to register tools on.
+ */
+export function registerCppTools(server) {
+    // --------------------------------------------------------------------------
+    // ue_read_cpp_class
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_read_cpp_class', {
+        title: 'Read UE C++ Class',
+        description: 'Read and parse a UE C++ header file, extracting UCLASS, UPROPERTY, and UFUNCTION declarations.',
+        inputSchema: z.object({
+            file_path: z.string().describe('Absolute path to the .h file'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+        },
+    }, withKnownIssues('ue_read_cpp_class', handleReadCppClass));
+    // --------------------------------------------------------------------------
+    // ue_get_class_hierarchy
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_get_class_hierarchy', {
+        title: 'Get UE Class Hierarchy',
+        description: 'Get the full inheritance hierarchy for a Unreal Engine C++ class.',
+        inputSchema: z.object({
+            class_name: z.string().describe('The UE class name (e.g., AActor, UObject)'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+        },
+    }, withKnownIssues('ue_get_class_hierarchy', handleGetClassHierarchy));
+    // --------------------------------------------------------------------------
+    // ue_trace_includes
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_trace_includes', {
+        title: 'Trace UE Include Chain',
+        description: 'Trace the #include chain for a UE C++ header file to identify circular or missing includes.',
+        inputSchema: z.object({
+            file_path: z.string().describe('Absolute path to the .h file to trace'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+        },
+    }, withKnownIssues('ue_trace_includes', handleTraceIncludes));
+    // --------------------------------------------------------------------------
+    // ue_find_class_file
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_find_class_file', {
+        title: 'Find UE Class File',
+        description: 'Locate the header file (.h) that declares a given UE C++ class name.',
+        inputSchema: z.object({
+            class_name: z.string().describe('The UE class name to find (e.g., APlayerController)'),
+        }),
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+        },
+    }, withKnownIssues('ue_find_class_file', handleFindClassFile));
+    // --------------------------------------------------------------------------
+    // ue_generate_class
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_generate_class', {
+        title: 'Generate UE C++ Class',
+        description: 'Generate a new UE C++ class (Actor, Component, GameMode, Interface, etc.) with correct UHT macros and boilerplate. Writes .h and .cpp files to the specified directory.',
+        inputSchema: z.object({
+            class_type: z.enum(['Actor', 'ActorComponent', 'SceneComponent', 'GameMode', 'GameState', 'PlayerState', 'PlayerController', 'Interface'])
+                .describe('The type of UE class to generate'),
+            class_name: z.string().describe('Class name without prefix (e.g., "MyActor" → "AMyActor")'),
+            module_name: z.string().describe('The module name (e.g., "MyGame") — used for the API macro'),
+            output_dir: z.string().describe('Absolute directory path where .h and .cpp will be written'),
+            parent_class: z.string().optional().describe('Optional parent class override (defaults by class_type)'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withKnownIssues('ue_generate_class', handleGenerateClass));
+    // --------------------------------------------------------------------------
+    // ue_add_property
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_add_property', {
+        title: 'Add UPROPERTY to UE Class',
+        description: 'Add a UPROPERTY declaration to an existing UE C++ header file. The property is inserted after the last existing UPROPERTY in the target class.',
+        inputSchema: z.object({
+            file_path: z.string().describe('Absolute path to the .h file'),
+            class_name: z.string().describe('The class to add the property to'),
+            specifiers: z.array(z.string()).describe('UPROPERTY specifiers (e.g., ["EditAnywhere", "BlueprintReadWrite"])'),
+            type: z.string().describe('Property type (e.g., "float", "AActor*", "TArray<FHitResult>")'),
+            name: z.string().describe('Property name (e.g., "Health")'),
+            default_value: z.string().optional().describe('Optional default value (e.g., "100.0f")'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withKnownIssues('ue_add_property', handleAddProperty));
+    // --------------------------------------------------------------------------
+    // ue_add_function
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_add_function', {
+        title: 'Add UFUNCTION to UE Class',
+        description: 'Add a UFUNCTION declaration to an existing UE C++ header file. The function signature is inserted after the last existing UFUNCTION in the target class.',
+        inputSchema: z.object({
+            file_path: z.string().describe('Absolute path to the .h file'),
+            class_name: z.string().describe('The class to add the function to'),
+            specifiers: z.array(z.string()).describe('UFUNCTION specifiers (e.g., ["BlueprintCallable", "Category=\\"Combat\\""])'),
+            return_type: z.string().describe('Return type (e.g., "void", "float", "FVector")'),
+            name: z.string().describe('Function name (e.g., "Attack")'),
+            params: z.string().optional().describe('Parameter list as raw string (e.g., "float Damage, AActor* Target")'),
+            is_const: z.boolean().optional().describe('Whether the function is const'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withKnownIssues('ue_add_function', handleAddFunction));
+    // --------------------------------------------------------------------------
+    // ue_add_include
+    // --------------------------------------------------------------------------
+    server.registerTool('ue_add_include', {
+        title: 'Add #include to UE C++ File',
+        description: 'Add an #include directive to an existing UE C++ header file. Inserts before the .generated.h include (UHT requirement). Idempotent — safe to call even if the include already exists.',
+        inputSchema: z.object({
+            file_path: z.string().describe('Absolute path to the .h or .cpp file'),
+            include_path: z.string().describe('Include path with quotes or angle brackets (e.g., \'"Engine/Actor.h"\' or \'<algorithm>\')'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false },
+    }, withKnownIssues('ue_add_include', handleAddInclude));
+}