unreal-engine-mcp-server 0.6.0-beta-e → 0.6.0

package/dist/tools/catalog/capabilities/records/system-control/performance.js

@@ -1,336 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-const PT = 'system_control';
-const DOM = 'performance';
-const FAM = 'performance';
-export const PERFORMANCE_RECORDS = [
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'start_profiling',
-        domain: DOM,
-        family: FAM,
-        summary: 'Start recording every stat group to a stats file (stat startfile), optionally stopping by itself after a duration.',
-        whenToUse: ['A named profiling capture must begin for CPU, GPU, memory, or thread analysis.'],
-        whenNotToUse: ['Only an HUD stat overlay is needed (use profile or show_stats).'],
-        inputProps: {
-            duration: { type: 'number', description: 'Seconds after which the capture stops by itself (default: runs until stop_profiling).' },
-        },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        dispatchAction: 'start_profiling',
-        exampleInput: { action: 'start_profiling', duration: 10 },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'stop_profiling',
-        domain: DOM,
-        family: FAM,
-        summary: 'Stop the active structured profiling capture.',
-        whenToUse: ['A profiling capture started by start_profiling must be stopped.'],
-        whenNotToUse: ['No profiling capture is running.'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        dispatchAction: 'stop_profiling',
-        exampleInput: { action: 'stop_profiling' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'run_benchmark',
-        domain: DOM,
-        family: FAM,
-        summary: 'Run an engine benchmark for a duration and return measured metrics.',
-        whenToUse: ['A timed benchmark must be executed and its metrics collected.'],
-        whenNotToUse: ['A continuous profiling capture is needed (use start_profiling).'],
-        inputProps: {
-            duration: { type: 'number', description: 'Benchmark duration in seconds (default 60).' },
-            type: { type: 'string', description: 'Optional benchmark type.' },
-        },
-        required: [],
-        effect: 'write',
-        behavior: { longRunning: true },
-        costLatency: 'long-running',
-        costResources: 'medium',
-        dispatchAction: 'run_benchmark',
-        exampleInput: { action: 'run_benchmark', duration: 30 },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'show_stats',
-        domain: DOM,
-        family: FAM,
-        summary: 'Show or hide a stat HUD overlay (e.g. Unit, GPU) in the active editor viewport; the call sets the state rather than toggling it.',
-        whenToUse: ['A specific stat category overlay must be shown or hidden.'],
-        whenNotToUse: ['Only the FPS counter is needed (use show_fps).'],
-        inputProps: {
-            category: { type: 'string', description: 'Stat category to display (e.g. Unit, GPU).' },
-            enabled: { type: 'boolean', description: 'Show (true, default) or hide (false) the overlay.' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'show_stats',
-        exampleInput: { action: 'show_stats', category: 'Unit', enabled: true },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'generate_memory_report',
-        domain: DOM,
-        family: FAM,
-        summary: 'Generate an engine memory report, optionally detailed.',
-        whenToUse: ['A snapshot of engine memory usage must be generated.'],
-        whenNotToUse: ['Live HUD memory stats are sufficient (use show_stats with memory).'],
-        inputProps: {
-            detailed: { type: 'boolean', description: 'Produce a detailed report.' },
-        },
-        required: [],
-        outputProps: {
-            reportPath: { type: 'string', description: 'Absolute path to the generated .memreport file.' },
-            reportDirectory: { type: 'string', description: 'Directory where memory reports are written.' },
-        },
-        outputRequired: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        dispatchAction: 'generate_memory_report',
-        exampleInput: { action: 'generate_memory_report', detailed: true },
-        exampleOutput: { success: true, message: 'Memory report generated', reportPath: 'Saved/Profiling/MemReports/Pid1234_12.34.56.memreport', reportDirectory: 'Saved/Profiling/MemReports' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'set_scalability',
-        domain: DOM,
-        family: FAM,
-        summary: 'Set one scalability group, or all of them, to a level 0-4 and save it as the editor scalability state.',
-        whenToUse: ['A scalability group level must be changed atomically.'],
-        whenNotToUse: ['A single CVar outside scalability groups is needed (use set_cvar).'],
-        inputProps: {
-            category: { type: 'string', description: 'Scalability group: ViewDistance, AntiAliasing, Shadow, GlobalIllumination, Reflection, PostProcess, Texture, Effects, Foliage or Shading. Omit (or Overall) to set every group.' },
-            level: { type: 'number', description: 'Level 0 (low) to 4 (cinematic), clamped. Required.' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'set_scalability',
-        exampleInput: { action: 'set_scalability', category: 'ViewDistance', level: 2 },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'set_resolution_scale',
-        domain: DOM,
-        family: FAM,
-        summary: 'Set the render resolution scale (r.ScreenPercentage) via the set_resolution_scale bridge action.',
-        whenToUse: ['The primary render resolution scale must be changed.'],
-        whenNotToUse: ['The window resolution must change (use set_resolution).'],
-        inputProps: { scale: { type: 'number', description: 'Resolution scale percentage.' } },
-        required: ['scale'],
-        effect: 'write',
-        dispatchAction: 'set_resolution_scale',
-        exampleInput: { action: 'set_resolution_scale', scale: 100 },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'set_vsync',
-        domain: DOM,
-        family: FAM,
-        summary: 'Enable or disable vertical sync via the set_vsync bridge action.',
-        whenToUse: ['VSync must be toggled at runtime.'],
-        whenNotToUse: ['A frame rate cap is the actual goal (use set_frame_rate_limit).'],
-        inputProps: { enabled: { type: 'boolean', description: 'Enable (true) or disable (false) VSync.' } },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'set_vsync',
-        exampleInput: { action: 'set_vsync', enabled: true },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'set_frame_rate_limit',
-        domain: DOM,
-        family: FAM,
-        summary: 'Set the engine frame rate cap via the set_frame_rate_limit bridge action.',
-        whenToUse: ['A maximum FPS cap must be applied.'],
-        whenNotToUse: ['VSync should be used instead for display-synced limiting.'],
-        inputProps: { maxFPS: { type: 'number', description: 'Maximum frames per second.' } },
-        required: ['maxFPS'],
-        effect: 'write',
-        dispatchAction: 'set_frame_rate_limit',
-        exampleInput: { action: 'set_frame_rate_limit', maxFPS: 60 },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'enable_gpu_timing',
-        domain: DOM,
-        family: FAM,
-        summary: 'Toggle GPU timing instrumentation via the manage_performance bridge action (subAction enable_gpu_timing).',
-        whenToUse: ['Per-frame GPU timing instrumentation must be enabled or disabled.'],
-        whenNotToUse: ['A full profiling capture is needed (use start_profiling).'],
-        inputProps: { enabled: { type: 'boolean', description: 'Enable (true) or disable (false) GPU timing.' } },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'manage_performance',
-        exampleInput: { action: 'enable_gpu_timing', enabled: true },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'configure_texture_streaming',
-        domain: DOM,
-        family: FAM,
-        summary: 'Configure texture streaming pool size and boost behavior via the configure_texture_streaming bridge action.',
-        whenToUse: ['Texture streaming pool size or player-location boost must be tuned.'],
-        whenNotToUse: ['A one-off texture import is the goal (use manage_asset).'],
-        inputProps: {
-            enabled: { type: 'boolean', description: 'Enable (true) or disable (false) streaming.' },
-            poolSize: { type: 'number', description: 'Streaming pool size in MB.' },
-            boostPlayerLocation: { type: 'boolean', description: 'Prioritize streaming around the player.' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'configure_texture_streaming',
-        exampleInput: { action: 'configure_texture_streaming', enabled: true, poolSize: 4096 },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'configure_lod',
-        domain: DOM,
-        family: FAM,
-        summary: 'Configure forced LOD and LOD bias via the configure_lod bridge action.',
-        whenToUse: ['A forced LOD level or LOD bias must be applied.'],
-        whenNotToUse: ['Per-actor LOD is the goal (use control_actor).'],
-        inputProps: {
-            forceLOD: { type: 'number', description: 'Forced LOD level.' },
-            lodBias: { type: 'number', description: 'Additional LOD bias.' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'configure_lod',
-        exampleInput: { action: 'configure_lod', lodBias: 1 },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'apply_baseline_settings',
-        domain: DOM,
-        family: FAM,
-        summary: 'Apply a named baseline performance profile via the apply_baseline_settings bridge action.',
-        whenToUse: ['A predefined performance baseline profile must be applied.'],
-        whenNotToUse: ['Individual CVars must be tuned (use set_cvar or set_scalability).'],
-        inputProps: { profile: { type: 'string', description: 'Baseline profile name (default balanced).' } },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        dispatchAction: 'apply_baseline_settings',
-        exampleInput: { action: 'apply_baseline_settings', profile: 'balanced' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'optimize_draw_calls',
-        domain: DOM,
-        family: FAM,
-        summary: 'Optimize draw calls via instancing/batching unless merge_actors is requested.',
-        whenToUse: ['Draw-call count must be reduced through instancing or batching.'],
-        whenNotToUse: ['Actors should be merged into a single mesh (use merge_actors).'],
-        inputProps: {
-            enabled: { type: 'boolean', description: 'Use cached mesh draw commands (r.MeshDrawCommands.UseCachedCommands).' },
-            enableBatching: { type: 'boolean', description: 'Same as enabled; enabled wins when both are given.' },
-            enableInstancing: { type: 'boolean', description: 'Dynamic instancing of mesh draw commands (r.MeshDrawCommands.DynamicInstancing).' },
-        },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        dispatchAction: 'optimize_draw_calls',
-        exampleInput: { action: 'optimize_draw_calls', enableInstancing: true },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'merge_actors',
-        domain: DOM,
-        family: FAM,
-        summary: 'Merge a set of actors into a single mesh (requires >=2 actor names) via the merge_actors bridge action.',
-        whenToUse: ['Two or more actors must be merged into one mesh asset.'],
-        whenNotToUse: ['Fewer than two actors are provided, or only instancing is needed (use optimize_draw_calls).'],
-        inputProps: {
-            actors: { type: 'array', items: { type: 'string' }, description: 'Actor names to merge (>=2 required).' },
-            replaceSourceActors: { type: 'boolean', description: 'Replace source actors in the level.' },
-            packageName: { type: 'string', description: 'Package name for the merged asset.' },
-            outputPath: { type: 'string', description: 'Output /Game folder for the merged asset.' },
-        },
-        required: ['actors'],
-        effect: 'write',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        dispatchAction: 'merge_actors',
-        exampleInput: { action: 'merge_actors', actors: ['Cube1', 'Cube2'], packageName: 'MergedCube' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'configure_occlusion_culling',
-        domain: DOM,
-        family: FAM,
-        summary: 'Configure occlusion culling via the configure_occlusion_culling bridge action.',
-        whenToUse: ['Occlusion culling must be enabled or its parameters tuned.'],
-        whenNotToUse: ['The scene is too small to benefit from occlusion culling.'],
-        inputProps: {
-            enabled: { type: 'boolean', description: 'Enable (true) or disable (false) occlusion culling.' },
-            slop: { type: 'number', description: 'Occlusion query bounds padding in world units (r.OcclusionSlop).' },
-            minScreenRadius: { type: 'number', description: 'Smallest screen radius an object needs to be occlusion tested (r.OcclusionCullMinScreenRadius).' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'configure_occlusion_culling',
-        exampleInput: { action: 'configure_occlusion_culling', enabled: true },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'optimize_shaders',
-        domain: DOM,
-        family: FAM,
-        summary: 'Optimize shader compilation via the optimize_shaders bridge action.',
-        whenToUse: ['Shader compilation must be optimized or force-recompiled.'],
-        whenNotToUse: ['A full material recompile is needed (use manage_asset compile_material).'],
-        inputProps: {
-            mode: { type: 'string', description: 'Optimization mode.' },
-            forceRecompile: { type: 'boolean', description: 'Force a shader recompile.' },
-        },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        dispatchAction: 'optimize_shaders',
-        exampleInput: { action: 'optimize_shaders', forceRecompile: false },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'configure_nanite',
-        domain: DOM,
-        family: FAM,
-        summary: 'Configure Nanite settings (enabled, max pixels per edge, streaming pool) via the configure_nanite bridge action.',
-        whenToUse: ['Nanite must be enabled or its runtime parameters tuned.'],
-        whenNotToUse: ['The target mesh is not Nanite-compatible.'],
-        inputProps: {
-            enabled: { type: 'boolean', description: 'Enable (true) or disable (false) Nanite.' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'configure_nanite',
-        exampleInput: { action: 'configure_nanite', enabled: true },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'configure_world_partition',
-        domain: DOM,
-        family: FAM,
-        summary: 'Configure world partition (enabled, cell size, loading range) via the configure_world_partition bridge action.',
-        whenToUse: ['World Partition runtime settings must be tuned.'],
-        whenNotToUse: ['Level streaming is managed per-sublevel (use manage_level).'],
-        inputProps: {
-            enabled: { type: 'boolean', description: 'Enable (true) or disable (false) world partition.' },
-            cellSize: { type: 'number', description: 'Partition cell size.' },
-            streamingDistance: { type: 'number', description: 'Loading/streaming range.' },
-        },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        dispatchAction: 'configure_world_partition',
-        exampleInput: { action: 'configure_world_partition', enabled: true, cellSize: 65536 },
-    }),
-];
-//# sourceMappingURL=performance.js.map

package/dist/tools/catalog/capabilities/records/system-control/plugins.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const PLUGIN_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=plugins.d.ts.map

package/dist/tools/catalog/capabilities/records/system-control/plugins.js

@@ -1,101 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-const PT = 'system_control';
-export const PLUGIN_RECORDS = [
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'list_plugins',
-        domain: 'project',
-        family: 'plugin',
-        topics: ['which are enabled', 'installed', 'content path'],
-        summary: 'List every plugin discovered by this editor with its enabled state, category, version and mounted content path; enabledOnly and filter (name or category) narrow the list.',
-        whenToUse: [
-            'A capability or migrated asset needs a plugin and its enabled state must be checked first.',
-            'The mounted content root of a plugin is needed in order to list the assets it ships.',
-        ],
-        whenNotToUse: ['Project content is being enumerated (use manage_asset list).'],
-        inputProps: {
-            filter: { type: 'string', description: 'Case-insensitive substring; a plugin is listed when its name or its category contains it.' },
-            enabledOnly: { type: 'boolean', description: 'Return only plugins currently enabled for this project.' },
-        },
-        outputProps: {
-            plugins: {
-                type: 'array',
-                description: 'Discovered plugins, name-sorted.',
-                items: {
-                    type: 'object',
-                    additionalProperties: false,
-                    properties: {
-                        name: { type: 'string', description: 'Plugin name — the .uplugin file name, and the value enable_plugin expects.' },
-                        enabled: { type: 'boolean', description: 'Enabled for this project.' },
-                        canContainContent: { type: 'boolean', description: 'Plugin declares a Content directory.' },
-                        friendlyName: { type: 'string', description: 'Display name from the descriptor.' },
-                        category: { type: 'string', description: 'Descriptor category, as grouped in the Plugins browser.' },
-                        versionName: { type: 'string', description: 'Descriptor version string.' },
-                        mountedContentPath: { type: 'string', description: 'Mounted content root (for example /ChaosVehiclesPlugin), empty when the plugin ships no content. Pass to manage_asset list to enumerate what it provides.' },
-                    },
-                },
-            },
-            pluginCount: { type: 'number', description: 'Number of plugins returned.' },
-        },
-        required: [],
-        effect: 'read',
-        costLatency: 'interactive',
-        dispatchAction: 'system_control',
-        exampleInput: { action: 'list_plugins', filter: 'Chaos' },
-        exampleOutput: { success: true, pluginCount: 3 },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'enable_plugin',
-        domain: 'project',
-        family: 'plugin',
-        summary: 'Enable a plugin for this project by writing it into the .uproject. The editor must be restarted before the plugin\'s modules load and its content mounts, so the response reports restartRequired.',
-        whenToUse: [
-            'Migrated content depends on a plugin that is installed but disabled (for example ChaosVehicles for the advanced vehicle template).',
-        ],
-        whenNotToUse: [
-            'The plugin is not installed at all — list_plugins returns NOT_FOUND and this cannot download it.',
-            'The effect is needed within the current session; this takes effect only after a restart.',
-        ],
-        inputProps: {
-            pluginName: { type: 'string', description: 'Plugin name exactly as reported by list_plugins (the .uplugin name, not the friendly name).' },
-        },
-        outputProps: {
-            pluginName: { type: 'string', description: 'Plugin acted on.' },
-            enabled: { type: 'boolean', description: 'Enabled state now recorded in the .uproject.' },
-            changed: { type: 'boolean', description: 'False when the plugin was already in the requested state and nothing was written.' },
-            restartRequired: { type: 'boolean', description: 'True whenever the project file changed; modules and content mount only at startup.' },
-        },
-        required: ['pluginName'],
-        effect: 'write',
-        costLatency: 'interactive',
-        dispatchAction: 'system_control',
-        exampleInput: { action: 'enable_plugin', pluginName: 'ChaosVehiclesPlugin' },
-        exampleOutput: { success: true, enabled: true, restartRequired: true },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'disable_plugin',
-        domain: 'project',
-        family: 'plugin',
-        summary: 'Disable a plugin for this project by removing it from the .uproject. Assets that depend on it fail to load after the restart, so confirm dependents first.',
-        whenToUse: ['A plugin enabled for a since-removed experiment should no longer load.'],
-        whenNotToUse: ['Project content still references the plugin\'s classes or assets.'],
-        inputProps: {
-            pluginName: { type: 'string', description: 'Plugin name exactly as reported by list_plugins.' },
-        },
-        outputProps: {
-            pluginName: { type: 'string', description: 'Plugin acted on.' },
-            enabled: { type: 'boolean', description: 'Enabled state now recorded in the .uproject.' },
-            changed: { type: 'boolean', description: 'False when the plugin was already disabled and nothing was written.' },
-            restartRequired: { type: 'boolean', description: 'True whenever the project file changed.' },
-        },
-        required: ['pluginName'],
-        effect: 'write',
-        costLatency: 'interactive',
-        dispatchAction: 'system_control',
-        exampleInput: { action: 'disable_plugin', pluginName: 'ChaosVehiclesPlugin' },
-        exampleOutput: { success: true, enabled: false, restartRequired: true },
-    }),
-];
-//# sourceMappingURL=plugins.js.map

package/dist/tools/catalog/capabilities/records/system-control/system-ops.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const SYSTEM_OPS_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=system-ops.d.ts.map