universal-game-modder 0.1.4

package/dist/tools/delegates/jar-editor.js

@@ -0,0 +1,276 @@
+import { childPool } from '../../backends/child-pool.js';
+import { logger } from '../../utils/logger.js';
+import { session } from '../../core/session.js';
+function delegateTool(name, description, inputSchema) {
+    return {
+        name,
+        description,
+        inputSchema,
+        handler: async (args) => {
+            const start = Date.now();
+            logger.toolStart(name, 'jar-editor');
+            try {
+                const result = await childPool.call('jar-editor', name, args);
+                const text = result.content.map(c => c.text).join('\n');
+                const duration = Date.now() - start;
+                logger.toolComplete(name, 'jar-editor', duration, !result.isError);
+                session.recordToolCall({ tool: name, timestamp: start, duration, success: !result.isError, backend: 'jar-editor' });
+                return text;
+            }
+            catch (err) {
+                const duration = Date.now() - start;
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.toolComplete(name, 'jar-editor', duration, false);
+                session.recordToolCall({ tool: name, timestamp: start, duration, success: false, backend: 'jar-editor' });
+                return `ERROR: ${msg}`;
+            }
+        },
+    };
+}
+export function getJarDelegateTools() {
+    return [
+        // Session Management
+        delegateTool('jar_open', 'Open and extract a JAR file for exploration and editing.', {
+            type: 'object',
+            properties: {
+                jar_path: { type: 'string', description: 'Path to the JAR file' },
+                session_id: { type: 'string', description: 'Optional custom session ID' },
+            },
+            required: ['jar_path'],
+        }),
+        delegateTool('jar_close', 'Close a JAR session and clean up temp files.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                cleanup: { type: 'boolean', description: 'Delete temp files (default: true)' },
+            },
+            required: ['session_id'],
+        }),
+        delegateTool('jar_list_sessions', 'List all active JAR sessions.', {
+            type: 'object',
+            properties: {},
+        }),
+        // Browse/Search
+        delegateTool('jar_list', 'List contents of an opened JAR file.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                filter_pattern: { type: 'string', description: 'Optional filename filter' },
+                max_results: { type: 'number', description: 'Max results (default 100)' },
+            },
+            required: ['session_id'],
+        }),
+        delegateTool('jar_search', 'Search within JAR for classes, methods, or strings.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                search_term: { type: 'string', description: 'Search term' },
+                search_type: { type: 'string', description: 'Type: filename, content, classname (default: filename)' },
+            },
+            required: ['session_id', 'search_term'],
+        }),
+        delegateTool('jar_search_bytecode', 'Search for numeric values or strings in bytecode.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                search_value: { type: 'string', description: 'Value to search for' },
+                file_filter: { type: 'string', description: 'Optional file filter pattern' },
+            },
+            required: ['session_id', 'search_value'],
+        }),
+        delegateTool('jar_search_opcodes', 'Search for bytecode opcode patterns in .class files.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                pattern: { type: 'string', description: 'Opcode pattern to search for' },
+                file_filter: { type: 'string', description: 'Optional file filter' },
+            },
+            required: ['session_id', 'pattern'],
+        }),
+        // Read/Inspect
+        delegateTool('jar_read_class', 'Read and decompile a Java .class file.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                class_path: { type: 'string', description: 'Path to .class file within JAR' },
+                decompile: { type: 'boolean', description: 'Decompile to Java source (default: true)' },
+                extra_classpath: { type: 'array', items: { type: 'string' }, description: 'Additional classpath entries' },
+            },
+            required: ['session_id', 'class_path'],
+        }),
+        delegateTool('jar_read_file', 'Read a text file from the JAR.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                file_path: { type: 'string', description: 'File path within JAR' },
+            },
+            required: ['session_id', 'file_path'],
+        }),
+        delegateTool('jar_inspect_constant_pool', 'Dump the constant pool of a .class file.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                class_path: { type: 'string', description: 'Path to .class file' },
+                filter_type: { type: 'string', description: 'Filter by constant type' },
+                filter_value: { type: 'string', description: 'Filter by value' },
+            },
+            required: ['session_id', 'class_path'],
+        }),
+        delegateTool('jar_hex_view', 'Read raw bytes from a .class file as hex dump.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                class_path: { type: 'string', description: 'Path to file' },
+                offset: { type: 'number', description: 'Start offset (default 0)' },
+                length: { type: 'number', description: 'Bytes to read (default 256)' },
+            },
+            required: ['session_id', 'class_path'],
+        }),
+        delegateTool('jar_detect_mod_info', 'Auto-detect mod loader, version, and structure from JAR contents.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+            },
+            required: ['session_id'],
+        }),
+        // Edit
+        delegateTool('jar_edit_file', 'Edit a text file within the JAR.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                file_path: { type: 'string', description: 'File path within JAR' },
+                new_content: { type: 'string', description: 'New file content' },
+            },
+            required: ['session_id', 'file_path', 'new_content'],
+        }),
+        delegateTool('jar_edit_class_constants', 'Edit numeric constants in .class file bytecode.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                class_path: { type: 'string', description: 'Path to .class file' },
+                replacements: { type: 'object', description: 'Map of old_value -> new_value' },
+                occurrence: { type: 'number', description: 'Which occurrence to replace (0-indexed)' },
+                value_type: { type: 'string', description: 'Value type hint' },
+            },
+            required: ['session_id', 'class_path', 'replacements'],
+        }),
+        delegateTool('jar_edit_constant_pool', 'Edit constants by their exact constant pool index.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                class_path: { type: 'string', description: 'Path to .class file' },
+                edits: { type: 'object', description: 'Map of pool_index -> new_value' },
+            },
+            required: ['session_id', 'class_path', 'edits'],
+        }),
+        delegateTool('jar_hex_edit', 'Write raw bytes at a specific offset in a file.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                class_path: { type: 'string', description: 'Path to file' },
+                offset: { type: 'number', description: 'Byte offset' },
+                hex_data: { type: 'string', description: 'Hex string to write' },
+            },
+            required: ['session_id', 'class_path', 'offset', 'hex_data'],
+        }),
+        // File Operations
+        delegateTool('jar_add_file', 'Add a file from disk into the JAR.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                jar_path: { type: 'string', description: 'Destination path within JAR' },
+                source_path: { type: 'string', description: 'Source file on disk' },
+                overwrite: { type: 'boolean', description: 'Overwrite if exists (default: true)' },
+            },
+            required: ['session_id', 'jar_path', 'source_path'],
+        }),
+        delegateTool('jar_add_file_content', 'Write text content as a new file in the JAR.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                jar_path: { type: 'string', description: 'Destination path within JAR' },
+                content: { type: 'string', description: 'File content' },
+                encoding: { type: 'string', description: 'Encoding (default: utf-8)' },
+            },
+            required: ['session_id', 'jar_path', 'content'],
+        }),
+        delegateTool('jar_compile_java', 'Compile Java source code and optionally inject into JAR.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                source_code: { type: 'string', description: 'Java source code' },
+                class_name: { type: 'string', description: 'Fully-qualified class name' },
+                classpath: { type: 'array', items: { type: 'string' }, description: 'Additional classpath entries' },
+                auto_classpath: { type: 'boolean', description: 'Auto-add JAR to classpath (default: true)' },
+                java_release: { type: 'number', description: 'Java release target (default: 21)' },
+                inject_into_jar: { type: 'boolean', description: 'Inject compiled class into JAR (default: true)' },
+            },
+            required: ['session_id', 'source_code', 'class_name'],
+        }),
+        // Diff/Restore
+        delegateTool('jar_diff', 'Show differences between original and modified file.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                class_path: { type: 'string', description: 'File path within JAR' },
+            },
+            required: ['session_id', 'class_path'],
+        }),
+        delegateTool('jar_restore_file', 'Restore a file from backup to undo modifications.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                class_path: { type: 'string', description: 'File path within JAR' },
+            },
+            required: ['session_id', 'class_path'],
+        }),
+        // Presets
+        delegateTool('jar_preset_save', 'Save a named preset of constant edits for reuse.', {
+            type: 'object',
+            properties: {
+                preset_name: { type: 'string', description: 'Preset name' },
+                description: { type: 'string', description: 'Preset description' },
+                class_path: { type: 'string', description: 'Target class path' },
+                edits: { type: 'object', description: 'Edit map' },
+                edit_mode: { type: 'string', description: 'Edit mode: constants or pool (default: constants)' },
+            },
+            required: ['preset_name', 'description', 'class_path', 'edits'],
+        }),
+        delegateTool('jar_preset_apply', 'Apply a saved preset of constant edits.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                preset_name: { type: 'string', description: 'Preset name to apply' },
+                reverse: { type: 'boolean', description: 'Reverse the edits (default: false)' },
+            },
+            required: ['session_id', 'preset_name'],
+        }),
+        delegateTool('jar_preset_list', 'List all saved edit presets.', {
+            type: 'object',
+            properties: {},
+        }),
+        // Repack/Scaffold
+        delegateTool('jar_repack', 'Repack the modified JAR file with all changes.', {
+            type: 'object',
+            properties: {
+                session_id: { type: 'string', description: 'Session ID' },
+                output_path: { type: 'string', description: 'Optional output path (defaults to original)' },
+            },
+            required: ['session_id'],
+        }),
+        delegateTool('jar_scaffold_mod', 'Generate a minimal Minecraft mod JAR structure.', {
+            type: 'object',
+            properties: {
+                mod_name: { type: 'string', description: 'Mod display name' },
+                mod_id: { type: 'string', description: 'Mod ID (lowercase, no spaces)' },
+                loader: { type: 'string', description: 'Mod loader: fabric, forge, neoforge (default: fabric)' },
+                mc_version: { type: 'string', description: 'Minecraft version (default: 1.21.5)' },
+                author: { type: 'string', description: 'Author name' },
+                description: { type: 'string', description: 'Mod description' },
+                output_dir: { type: 'string', description: 'Output directory' },
+            },
+            required: ['mod_name', 'mod_id', 'output_dir'],
+        }),
+    ];
+}
+//# sourceMappingURL=jar-editor.js.map

package/dist/tools/delegates/unity-decompiler.d.ts

@@ -0,0 +1,2 @@
+import { ToolDefinition } from '../index.js';
+export declare function getUnityDelegateTools(): ToolDefinition[];

package/dist/tools/delegates/unity-decompiler.js

@@ -0,0 +1,291 @@
+import { childPool } from '../../backends/child-pool.js';
+import { logger } from '../../utils/logger.js';
+import { session } from '../../core/session.js';
+function delegateTool(name, description, inputSchema, postProcess) {
+    return {
+        name,
+        description,
+        inputSchema,
+        handler: async (args) => {
+            const start = Date.now();
+            logger.toolStart(name, 'unity-decompiler');
+            try {
+                const result = await childPool.call('unity-decompiler', name, args);
+                const text = result.content.map(c => c.text).join('\n');
+                const duration = Date.now() - start;
+                logger.toolComplete(name, 'unity-decompiler', duration, !result.isError);
+                session.recordToolCall({ tool: name, timestamp: start, duration, success: !result.isError, backend: 'unity-decompiler' });
+                if (postProcess && !result.isError)
+                    postProcess(text, args);
+                return text;
+            }
+            catch (err) {
+                const duration = Date.now() - start;
+                const msg = err instanceof Error ? err.message : String(err);
+                logger.toolComplete(name, 'unity-decompiler', duration, false);
+                session.recordToolCall({ tool: name, timestamp: start, duration, success: false, backend: 'unity-decompiler' });
+                return `ERROR: ${msg}`;
+            }
+        },
+    };
+}
+export function getUnityDelegateTools() {
+    return [
+        // Phase 1: Understanding
+        delegateTool('load_assembly', 'Load a .NET assembly (DLL) for analysis. Must be called before other Unity tools.', {
+            type: 'object',
+            properties: {
+                assembly_path: { type: 'string', description: 'Full path to the .NET DLL file' },
+                managed_directory: { type: 'string', description: 'Optional: path to the Managed directory for dependency resolution' },
+            },
+            required: ['assembly_path'],
+        }),
+        delegateTool('list_types', 'List all types (classes, structs, enums, interfaces) in a loaded assembly.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key (from load_assembly)' },
+                filter: { type: 'string', description: 'Filter by name (substring match)' },
+                kind: { type: 'string', description: 'Filter by kind: class, struct, enum, interface' },
+                base_type: { type: 'string', description: 'Filter by base type name' },
+                limit: { type: 'number', description: 'Max results (default 200)' },
+            },
+            required: ['assembly'],
+        }),
+        delegateTool('decompile_type', 'Decompile a type to full C# source code.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                type_name: { type: 'string', description: 'Full type name (Namespace.ClassName)' },
+            },
+            required: ['assembly', 'type_name'],
+        }, (result, args) => {
+            session.cacheDecompilation(args.type_name, result);
+        }),
+        delegateTool('decompile_method', 'Decompile a single method to C# source code.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                type_name: { type: 'string', description: 'Full type name' },
+                method_name: { type: 'string', description: 'Method name' },
+                parameter_count: { type: 'number', description: 'Parameter count to disambiguate overloads' },
+            },
+            required: ['assembly', 'type_name', 'method_name'],
+        }),
+        delegateTool('inspect_type', 'Inspect type structure (fields, properties, methods) without decompiling method bodies.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                type_name: { type: 'string', description: 'Full type name' },
+            },
+            required: ['assembly', 'type_name'],
+        }),
+        delegateTool('search_code', 'Search across assembly for types, methods, fields, or string literals.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                pattern: { type: 'string', description: 'Search pattern' },
+                scope: { type: 'string', description: 'Search scope: all, types, methods, fields, strings (default: all)' },
+                limit: { type: 'number', description: 'Max results (default 100)' },
+            },
+            required: ['assembly', 'pattern'],
+        }),
+        delegateTool('find_references', 'Find all references to a method or field.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                type_name: { type: 'string', description: 'Type containing the member' },
+                member_name: { type: 'string', description: 'Member name to find references to' },
+                limit: { type: 'number', description: 'Max results (default 100)' },
+            },
+            required: ['assembly', 'type_name', 'member_name'],
+        }),
+        delegateTool('get_inheritance_tree', 'Get full inheritance tree for a type (ancestors and descendants).', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                type_name: { type: 'string', description: 'Full type name' },
+            },
+            required: ['assembly', 'type_name'],
+        }),
+        delegateTool('list_monobehaviours', 'List all MonoBehaviour components in assembly.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                filter: { type: 'string', description: 'Optional name filter' },
+                limit: { type: 'number', description: 'Max results (default 200)' },
+            },
+            required: ['assembly'],
+        }),
+        delegateTool('list_scriptableobjects', 'List all ScriptableObject types in assembly.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                filter: { type: 'string', description: 'Optional name filter' },
+            },
+            required: ['assembly'],
+        }),
+        delegateTool('get_serialized_fields', 'Get all serialized fields for a MonoBehaviour or ScriptableObject.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                type_name: { type: 'string', description: 'Full type name' },
+            },
+            required: ['assembly', 'type_name'],
+        }),
+        delegateTool('get_method_il', 'Get raw IL bytecode for a method.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                type_name: { type: 'string', description: 'Full type name' },
+                method_name: { type: 'string', description: 'Method name' },
+            },
+            required: ['assembly', 'type_name', 'method_name'],
+        }),
+        // Phase 2: Mod Building
+        delegateTool('generate_plugin', 'Generate complete BepInEx 5 plugin template with Harmony patching.', {
+            type: 'object',
+            properties: {
+                plugin_name: { type: 'string', description: 'Plugin class name' },
+                plugin_guid: { type: 'string', description: 'Plugin GUID (e.g. com.author.pluginname)' },
+                version: { type: 'string', description: 'Version string (default 1.0.0)' },
+                description: { type: 'string', description: 'Plugin description' },
+                author: { type: 'string', description: 'Author name' },
+                include_harmony: { type: 'boolean', description: 'Include Harmony setup' },
+                include_config: { type: 'boolean', description: 'Include config system' },
+                managed_directory: { type: 'string', description: 'Path to game Managed directory' },
+            },
+            required: ['plugin_name', 'plugin_guid'],
+        }),
+        delegateTool('generate_harmony_patch', 'Generate correct Harmony patch class for a specific method.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                type_name: { type: 'string', description: 'Target type name' },
+                method_name: { type: 'string', description: 'Target method name' },
+                patch_type: { type: 'string', description: 'Patch type: prefix, postfix, both (default: both)' },
+                parameter_count: { type: 'number', description: 'Parameter count for overload disambiguation' },
+                patch_class_name: { type: 'string', description: 'Custom name for the patch class' },
+            },
+            required: ['assembly', 'type_name', 'method_name'],
+        }),
+        delegateTool('validate_patch_target', 'Validate that a Harmony patch target method exists with expected signature.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                type_name: { type: 'string', description: 'Target type name' },
+                method_name: { type: 'string', description: 'Target method name' },
+                expected_params: { type: 'string', description: 'Expected parameter types (comma-separated)' },
+                expected_return: { type: 'string', description: 'Expected return type' },
+            },
+            required: ['assembly', 'type_name', 'method_name'],
+        }),
+        delegateTool('list_patchable_methods', 'List all methods in a type that can be Harmony patched.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+                type_name: { type: 'string', description: 'Full type name' },
+                filter: { type: 'string', description: 'Optional method name filter' },
+                include_inherited: { type: 'boolean', description: 'Include inherited methods (default: false)' },
+            },
+            required: ['assembly', 'type_name'],
+        }),
+        delegateTool('compile_plugin', 'Compile a BepInEx plugin C# source file using Roslyn.', {
+            type: 'object',
+            properties: {
+                source_files: { type: 'string', description: 'C# source file path(s), semicolon-separated' },
+                managed_directory: { type: 'string', description: 'Path to game Managed directory' },
+                bepinex_core_directory: { type: 'string', description: 'Path to BepInEx/core directory' },
+                output_path: { type: 'string', description: 'Output DLL path' },
+                assembly_name: { type: 'string', description: 'Assembly name (optional)' },
+            },
+            required: ['source_files', 'managed_directory', 'bepinex_core_directory', 'output_path'],
+        }),
+        // Phase 3: Debugging
+        delegateTool('analyze_bepinex_log', 'Analyze BepInEx log for errors, warnings, and patch issues.', {
+            type: 'object',
+            properties: {
+                log_path: { type: 'string', description: 'Path to BepInEx LogOutput.log' },
+            },
+            required: ['log_path'],
+        }),
+        delegateTool('validate_assembly', 'Validate compiled plugin DLL for missing references and conflicts.', {
+            type: 'object',
+            properties: {
+                plugin_path: { type: 'string', description: 'Path to compiled plugin DLL' },
+                managed_directory: { type: 'string', description: 'Path to game Managed directory' },
+            },
+            required: ['plugin_path', 'managed_directory'],
+        }),
+        delegateTool('compare_signatures', 'Compare expected Harmony patch signature with actual target method.', {
+            type: 'object',
+            properties: {
+                game_assembly: { type: 'string', description: 'Assembly key' },
+                target_type: { type: 'string', description: 'Target type name' },
+                target_method: { type: 'string', description: 'Target method name' },
+                patch_params: { type: 'string', description: 'Patch parameter types (comma-separated)' },
+                patch_kind: { type: 'string', description: 'Patch kind: prefix or postfix (default: prefix)' },
+            },
+            required: ['game_assembly', 'target_type', 'target_method', 'patch_params'],
+        }),
+        // Phase 4: Advanced
+        delegateTool('read_unity_assets_info', 'List Unity asset files in game data directory.', {
+            type: 'object',
+            properties: {
+                data_directory: { type: 'string', description: 'Path to game _Data directory' },
+            },
+            required: ['data_directory'],
+        }),
+        delegateTool('read_playerprefs', 'Read Unity PlayerPrefs from Windows registry.', {
+            type: 'object',
+            properties: {
+                company_name: { type: 'string', description: 'Company name from PlayerSettings' },
+                product_name: { type: 'string', description: 'Product name from PlayerSettings' },
+                filter: { type: 'string', description: 'Optional key filter' },
+            },
+            required: ['company_name', 'product_name'],
+        }),
+        delegateTool('analyze_save_format', 'Analyze game save system by examining SaveManager classes.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+            },
+            required: ['assembly'],
+        }),
+        delegateTool('detect_networking', 'Detect networking frameworks and flag unsafe-to-patch methods.', {
+            type: 'object',
+            properties: {
+                assembly: { type: 'string', description: 'Assembly key' },
+            },
+            required: ['assembly'],
+        }),
+        // Phase 5: Maintenance
+        delegateTool('diff_assemblies', 'Compare two assembly versions to show changes.', {
+            type: 'object',
+            properties: {
+                old_assembly_path: { type: 'string', description: 'Path to old version DLL' },
+                new_assembly_path: { type: 'string', description: 'Path to new version DLL' },
+                show_methods: { type: 'boolean', description: 'Show method-level changes (default: true)' },
+                limit: { type: 'number', description: 'Max results (default 200)' },
+            },
+            required: ['old_assembly_path', 'new_assembly_path'],
+        }),
+        delegateTool('find_renamed_types', 'Find types likely renamed after a game update.', {
+            type: 'object',
+            properties: {
+                old_assembly_path: { type: 'string', description: 'Path to old version DLL' },
+                new_assembly_path: { type: 'string', description: 'Path to new version DLL' },
+                min_similarity: { type: 'number', description: 'Min similarity threshold 0-1 (default: 0.6)' },
+            },
+            required: ['old_assembly_path', 'new_assembly_path'],
+        }),
+        delegateTool('verify_patches', 'Verify Harmony patch targets in plugin still exist in game assembly.', {
+            type: 'object',
+            properties: {
+                plugin_path: { type: 'string', description: 'Path to compiled plugin DLL' },
+                game_assembly: { type: 'string', description: 'Path to game Assembly-CSharp.dll' },
+            },
+            required: ['plugin_path', 'game_assembly'],
+        }),
+    ];
+}
+//# sourceMappingURL=unity-decompiler.js.map

package/dist/tools/delegates/unreal-assets.d.ts

@@ -0,0 +1,2 @@
+import { ToolDefinition } from '../index.js';
+export declare function getUnrealDelegateTools(): ToolDefinition[];