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

package/dist/tools/catalog/capabilities/records/inspect/component-actor.data.js

@@ -1,182 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-import { P } from './properties.js';
-const D = 'inspect';
-export const COMPONENT_ACTOR_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_components', dispatchAction: 'get_components', domain: D, family: 'components',
-        topics: ['list components', 'actor components', 'component list', 'components of actor'],
-        aliases: ['inspect.list_components'],
-        summary: 'List components on a world actor (or a Blueprint CDO when blueprintPath is supplied).',
-        whenToUse: ['An actor\'s component list must be enumerated.'],
-        whenNotToUse: ['A single component\'s properties are needed; use get_component_property.'],
-        inputProps: {
-            objectPath: P.objectPath, actorName: P.actorName, name: P.name, blueprintPath: P.blueprintPath,
-            componentNames: { type: 'array', items: { type: 'string' }, description: 'Return only these components, by name (case-insensitive); a name that matches none is listed under missingComponents.' },
-        },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_components', actorName: 'PlayerStart_1' },
-        exampleOutput: { success: true, message: 'Components listed', components: [] },
-        outputProps: {
-            components: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Component info objects: name, class, parent, source. A mesh component also carries staticMesh and materials (the material drawn in each slot, overrides included); a Blueprint component also carries its relative location/rotation/scale and visible.' },
-            missingComponents: { type: 'array', items: { type: 'string' }, description: 'componentNames that matched no component.' },
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_component_property', dispatchAction: 'control_actor', domain: D, family: 'components',
-        summary: 'Read a property on a world actor component (cross-parent to control_actor).',
-        whenToUse: ['A single component property value must be read.'],
-        whenNotToUse: ['The whole component is needed; use get_component_details.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name, componentName: P.componentName, propertyName: P.propertyName, propertyPath: P.propertyPath, blueprintPath: P.blueprintPath },
-        required: ['componentName'],
-        requiredOneOf: ['propertyName', 'propertyPath'],
-        effect: 'read',
-        exampleInput: { action: 'get_component_property', actorName: 'PlayerStart_1', componentName: 'Billboard', propertyName: 'Sprite' },
-        exampleOutput: { success: true, message: 'Component property read', value: null },
-        outputProps: { value: P.valueRead },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'set_component_property', dispatchAction: 'control_actor', domain: D, family: 'components',
-        summary: 'Write a property on a world actor component (cross-parent to control_actor).',
-        whenToUse: ['A single component property value must be written.'],
-        whenNotToUse: ['The component does not own the property; use get_components to enumerate.'],
-        inputProps: {
-            objectPath: P.objectPath, actorName: P.actorName, name: P.name, componentName: P.componentName, propertyName: P.propertyName, propertyPath: P.propertyPath, value: P.value,
-            properties: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true, description: 'Several component properties at once, name or dotted path to value, in place of propertyName and value.' },
-        },
-        required: ['componentName'],
-        requiredOneOf: ['properties', 'propertyName', 'propertyPath'],
-        effect: 'write', costLatency: 'interactive',
-        exampleInput: { action: 'set_component_property', actorName: 'PlayerStart_1', componentName: 'Billboard', propertyName: 'Sprite', value: null },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_component_details', dispatchAction: 'control_actor', domain: D, family: 'components',
-        summary: 'Return a single component of a world actor (TS dispatches get_components to control_actor and filters locally).',
-        whenToUse: ['One component\'s full details must be read.'],
-        whenNotToUse: ['All components are needed; use get_components.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name, componentName: P.componentName, blueprintPath: P.blueprintPath, propertyNames: P.propertyNames },
-        required: ['componentName'],
-        effect: 'read',
-        exampleInput: { action: 'get_component_details', actorName: 'PlayerStart_1', componentName: 'Billboard' },
-        exampleOutput: { success: true, message: 'Component details', componentName: 'Billboard' },
-        outputProps: { componentName: P.componentName },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_metadata', dispatchAction: 'control_actor', domain: D, family: 'actor',
-        summary: 'Read metadata key/value pairs from a world actor (cross-parent to control_actor).',
-        whenToUse: ['An actor\'s metadata must be inspected.'],
-        whenNotToUse: ['Metadata must be written; use manage_asset or control_actor set_metadata.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_metadata', actorName: 'PlayerStart_1' },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'add_tag', dispatchAction: 'control_actor', domain: D, family: 'actor',
-        summary: 'Add a tag to a world actor (cross-parent to control_actor).',
-        whenToUse: ['A tag must be added to an actor for grouping or queries.'],
-        whenNotToUse: ['The actor already has the tag.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, actorNames: P.actorNames, name: P.name, tag: P.tag },
-        required: ['tag'],
-        effect: 'write', behavior: { idempotency: 'idempotent' },
-        exampleInput: { action: 'add_tag', actorName: 'PlayerStart_1', tag: 'Spawn' },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'find_by_tag', dispatchAction: 'control_actor', domain: D, family: 'actor',
-        summary: 'Find world actors by tag (cross-parent to control_actor).',
-        whenToUse: ['All actors with a given tag must be enumerated.'],
-        whenNotToUse: ['Actors must be found by class; use find_by_class.'],
-        inputProps: { tag: P.tag },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'find_by_tag', tag: 'Spawn' },
-        exampleOutput: { success: true, message: 'Actors found', actors: [] },
-        outputProps: { actors: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Matching actor info objects.' } },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'create_snapshot', dispatchAction: 'control_actor', domain: D, family: 'snapshot',
-        summary: 'Create a property snapshot of a world actor (cross-parent to control_actor).',
-        whenToUse: ['An actor\'s state must be captured for later restore.'],
-        whenNotToUse: ['No restore is planned.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name, snapshotName: P.snapshotName },
-        required: [],
-        effect: 'write', costLatency: 'interactive',
-        exampleInput: { action: 'create_snapshot', actorName: 'PlayerStart_1', snapshotName: 'snap_01' },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'restore_snapshot', dispatchAction: 'control_actor', domain: D, family: 'snapshot',
-        summary: 'Restore a previously created property snapshot onto a world actor (cross-parent to control_actor).',
-        whenToUse: ['An actor\'s state must be restored from a snapshot.'],
-        whenNotToUse: ['No snapshot exists for the actor.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name, snapshotName: P.snapshotName },
-        required: [],
-        effect: 'write', behavior: { idempotency: 'idempotent' }, costLatency: 'interactive',
-        exampleInput: { action: 'restore_snapshot', actorName: 'PlayerStart_1', snapshotName: 'snap_01' },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'export', dispatchAction: 'control_actor', domain: D, family: 'actor',
-        summary: 'Export a world actor or object as text (T3D by default), returned inline as exportedText and, with outputPath, also written to a file inside the project.',
-        whenToUse: ['An actor must be serialized to text or to an external file.'],
-        whenNotToUse: ['The actor should be duplicated in-scene; use control_actor duplicate.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name, format: P.format, outputPath: P.outputPath },
-        required: [],
-        effect: 'read', costLatency: 'interactive',
-        exampleInput: { action: 'export', actorName: 'PlayerStart_1' },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'delete_object', dispatchAction: 'control_actor', domain: D, family: 'actor',
-        summary: 'Delete a world actor by name (cross-parent to control_actor; dispatches action delete).',
-        whenToUse: ['A world actor must be permanently removed from the level.'],
-        whenNotToUse: ['The target is an asset path; use manage_asset delete (TS returns a NOT_FOUND hint).'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, actorNames: P.actorNames, name: P.name },
-        required: [],
-        effect: 'destructive', costLatency: 'interactive',
-        exampleInput: { action: 'delete_object', actorName: 'PlayerStart_1' },
-        exampleOutput: { success: true, message: 'Actor deleted', deleted: 'PlayerStart_1' },
-        outputProps: { deleted: { type: 'string', description: 'Name of the deleted actor.' } },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'list_objects', dispatchAction: 'control_actor', domain: D, family: 'actor',
-        outputProps: {
-            count: { type: 'number', description: 'Number of actors returned.' },
-            totalCount: { type: 'number', description: 'Total actor count in the world.' },
-            isPieWorld: { type: 'boolean', description: 'Whether the world is a PIE world.' },
-            worldName: { type: 'string', description: 'Name of the current world.' },
-            actors: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Actor info objects.' },
-        },
-        topics: ['world objects', 'enumerate objects'],
-        summary: 'List world actors (cross-parent to control_actor; dispatches action list_actors).',
-        whenToUse: ['All actors in the current level must be enumerated.'],
-        whenNotToUse: ['Only tagged actors are needed; use find_by_tag.'],
-        inputProps: { filter: P.filter, limit: P.limit, offset: P.offset },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'list_objects' },
-        exampleOutput: { success: true, message: 'Actors listed', actors: [] },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'find_by_class', dispatchAction: 'find_by_class', domain: D, family: 'actor',
-        topics: ['all actors of a type', 'every instance'],
-        summary: 'Find the actors of a class in the level, by class name or /Script path: returns each match\'s name, path and class plus a count. Searches the PIE world while a game runs.',
-        whenToUse: ['All actors of a specific class must be enumerated.'],
-        whenNotToUse: ['Actors must be found by tag; use find_by_tag.'],
-        inputProps: { className: P.className, classPath: P.classPath },
-        required: [],
-        requiredOneOf: ['className', 'classPath'],
-        effect: 'read',
-        exampleInput: { action: 'find_by_class', className: 'PointLight' },
-        exampleOutput: { success: true, message: 'Actors found', objects: [] },
-        outputProps: { objects: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Matching object info.' } },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_bounding_box', dispatchAction: 'control_actor', domain: D, family: 'actor',
-        summary: 'Return the world-space bounding box of a world actor (cross-parent to control_actor).',
-        whenToUse: ['An actor\'s bounds must be read.'],
-        whenNotToUse: ['The actor does not have a visible mesh.'],
-        inputProps: { objectPath: P.objectPath, actorName: P.actorName, name: P.name },
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_bounding_box', actorName: 'Cube_1' },
-    }),
-];
-//# sourceMappingURL=component-actor.data.js.map

package/dist/tools/catalog/capabilities/records/inspect/global.data.d.ts

@@ -1,4 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const GLOBAL_RECORDS: readonly CapabilityRecordSource[];
-export declare const EDITOR_SETTINGS_RECORD: CapabilityRecordSource;
-//# sourceMappingURL=global.data.d.ts.map

package/dist/tools/catalog/capabilities/records/inspect/global.data.js

@@ -1,121 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-const D = 'inspect';
-export const GLOBAL_RECORDS = [
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_project_settings', dispatchAction: 'get_project_settings', domain: D, family: 'global',
-        topics: ['project settings', 'project config', 'engine version', 'project name', 'game settings'],
-        summary: 'Return project settings key/value pairs.',
-        whenToUse: ['Project settings must be inspected.'],
-        whenNotToUse: ['Editor settings are needed; use get_editor_settings.'],
-        inputProps: {},
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_project_settings' },
-        exampleOutput: {
-            success: true, message: 'Project settings', projectName: 'Demo',
-            engineVersion: '5.6.0-0+++UE5', buildConfig: 'Development',
-            projectDir: '../../../Demo/', projectVersion: '1.0.0.0', companyName: 'Acme',
-        },
-        outputProps: {
-            projectName: { type: 'string', description: 'Project name.' },
-            engineVersion: { type: 'string', description: 'Unreal Engine version string.' },
-            buildConfig: { type: 'string', description: 'Build configuration, e.g. Development.' },
-            projectDir: { type: 'string', description: 'Project directory on disk.' },
-            description: { type: 'string', description: 'Project description.' },
-            homepage: { type: 'string', description: 'Project homepage URL.' },
-            supportContact: { type: 'string', description: 'Project support contact.' },
-            projectVersion: { type: 'string', description: 'Project version string.' },
-            companyName: { type: 'string', description: 'Company name.' },
-            copyrightNotice: { type: 'string', description: 'Copyright notice.' },
-            projectID: { type: 'string', description: 'Project GUID.' },
-            startInVR: { type: 'boolean', description: 'Whether the project starts in VR.' },
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_world_settings', dispatchAction: 'get_world_settings', domain: D, family: 'global',
-        summary: 'Return the current world/level settings summary (worldName, gravity, killZ, time).',
-        whenToUse: ['The current level\'s world settings must be inspected.'],
-        whenNotToUse: ['Project-wide settings are needed; use get_project_settings.'],
-        inputProps: {},
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_world_settings' },
-        exampleOutput: {
-            success: true, message: 'World settings', worldName: 'Demo', levelName: 'Demo',
-            packageName: '/Game/Maps/Demo', timeSeconds: 12.5, realTimeSeconds: 30.2,
-            deltaTimeSeconds: 0.0166, hasBegunPlay: false, isPlayInEditor: false,
-            killZ: -1048575, worldGravityZ: -980, timeDilation: 1, enableWorldBoundsChecks: true,
-            defaultGameMode: '/Game/Blueprints/BP_GameMode.BP_GameMode_C',
-        },
-        outputProps: {
-            worldName: { type: 'string', description: 'Current world name.' },
-            levelName: { type: 'string', description: 'Current level name.' },
-            packageName: { type: 'string', description: 'Package name of the world asset.' },
-            timeSeconds: { type: 'number', description: 'World time in seconds.' },
-            realTimeSeconds: { type: 'number', description: 'Real (unpaused) time in seconds.' },
-            deltaTimeSeconds: { type: 'number', description: 'Last frame delta in seconds.' },
-            hasBegunPlay: { type: 'boolean', description: 'Whether the world has begun play.' },
-            isPlayInEditor: { type: 'boolean', description: 'Whether this world is a PIE world.' },
-            killZ: { type: 'number', description: 'Z height below which actors are killed.' },
-            worldGravityZ: { type: 'number', description: 'World gravity along Z.' },
-            timeDilation: { type: 'number', description: 'Global time dilation multiplier.' },
-            enableWorldBoundsChecks: { type: 'boolean', description: 'Whether world bounds checks are enabled.' },
-            defaultGameMode: { type: 'string', description: 'Default GameMode class path set on WorldSettings.' },
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_viewport_info', dispatchAction: 'get_viewport_info', domain: D, family: 'global',
-        summary: 'Return viewport information (view target, camera manager, world type).',
-        whenToUse: ['Viewport and camera state must be inspected.'],
-        whenNotToUse: ['A screenshot is needed; use control_editor.'],
-        inputProps: {},
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_viewport_info' },
-        exampleOutput: { success: true, message: 'Viewport info', width: 1920, height: 1080 },
-        outputProps: {
-            width: { type: 'number', description: 'Active viewport width in pixels.' },
-            height: { type: 'number', description: 'Active viewport height in pixels.' },
-            shadersCompiling: { type: 'number', description: 'Every get_editor_state variant: shader compile jobs still outstanding. Above 0 the viewport, and a screenshot of it, shows the engine default material (black foliage, grey ground) for what they cover; a warning says so.' },
-        },
-    }),
-    buildCoreRecord({
-        parentTool: 'inspect', action: 'get_selected_actors', dispatchAction: 'get_selected_actors', domain: D, family: 'global',
-        topics: ['selected actors', 'selection', 'what is selected', 'current selection', 'editor selection'],
-        summary: 'Return the actors currently selected in the editor viewport.',
-        whenToUse: ['The current editor selection must be inspected.'],
-        whenNotToUse: ['All actors are needed; use list_objects.'],
-        inputProps: {},
-        required: [],
-        effect: 'read',
-        exampleInput: { action: 'get_selected_actors' },
-        exampleOutput: { success: true, message: 'Selected actors', actors: [] },
-        outputProps: { actors: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Selected actor info objects.' } },
-    }),
-];
-export const EDITOR_SETTINGS_RECORD = buildCoreRecord({
-    parentTool: 'inspect', action: 'get_editor_settings', dispatchAction: 'get_editor_settings', domain: D, family: 'global',
-    summary: 'Return editor settings key/value pairs.',
-    whenToUse: ['Editor settings must be inspected.'],
-    whenNotToUse: ['Project settings are needed; use get_project_settings.'],
-    inputProps: {},
-    required: [],
-    effect: 'read',
-    exampleInput: { action: 'get_editor_settings' },
-    exampleOutput: {
-        success: true, message: 'Editor settings', mouseSensitivity: 1.0, mouseScrollCameraSpeed: 1.0,
-        useDistanceScaledCamera: false, isSimulating: false, isPIEActive: false,
-        gameAgnosticSavedFPS: 60, isEditor: true, gRunningCommandlet: 0,
-    },
-    outputProps: {
-        mouseSensitivity: { type: 'number', description: 'Viewport mouse sensitivity.' },
-        mouseScrollCameraSpeed: { type: 'number', description: 'Mouse scroll camera speed.' },
-        useDistanceScaledCamera: { type: 'boolean', description: 'Whether distance-scaled camera speed is used.' },
-        isSimulating: { type: 'boolean', description: 'Whether the editor is simulating.' },
-        isPIEActive: { type: 'boolean', description: 'Whether a PIE session is active.' },
-        gameAgnosticSavedFPS: { type: 'number', description: 'Saved game-agnostic max FPS.' },
-        isEditor: { type: 'boolean', description: 'Whether running in the editor.' },
-        gRunningCommandlet: { type: 'number', description: '1 when running as a commandlet, else 0.' },
-    },
-});
-//# sourceMappingURL=global.data.js.map

package/dist/tools/catalog/capabilities/records/inspect/index.d.ts

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

package/dist/tools/catalog/capabilities/records/inspect/index.js

@@ -1,17 +0,0 @@
-import { COMPONENT_ACTOR_RECORDS } from './component-actor.data.js';
-import { EDITOR_SETTINGS_RECORD, GLOBAL_RECORDS } from './global.data.js';
-import { RUNTIME_RECORDS } from './runtime.data.js';
-import { STATS_RECORDS } from './stats.data.js';
-import { OBJECT_PROPERTY_RECORDS } from './object-property.data.js';
-import { applyFolds } from '../shared/fold.js';
-import { INSPECT_FOLDS } from '../folds/inspect.folds.js';
-export const INSPECT_UNFOLDED_SOURCES = [
-    ...OBJECT_PROPERTY_RECORDS,
-    ...COMPONENT_ACTOR_RECORDS,
-    ...RUNTIME_RECORDS,
-    ...GLOBAL_RECORDS,
-    ...STATS_RECORDS,
-    EDITOR_SETTINGS_RECORD,
-];
-export const INSPECT_SOURCES = applyFolds(INSPECT_UNFOLDED_SOURCES, INSPECT_FOLDS, 'inspect');
-//# sourceMappingURL=index.js.map

package/dist/tools/catalog/capabilities/records/inspect/inspect-records.shared.d.ts

@@ -1,3 +0,0 @@
-export declare const INSPECT_UNFOLDED_RECORDS: import("../../model.js").CapabilityRecord[];
-export declare function findByAction(action: string): import("../../model.js").CapabilityRecord;
-//# sourceMappingURL=inspect-records.shared.d.ts.map

package/dist/tools/catalog/capabilities/records/inspect/inspect-records.shared.js

@@ -1,9 +0,0 @@
-import { ALL_UNFOLDED_CAPABILITY_RECORDS } from '../unfolded.js';
-export const INSPECT_UNFOLDED_RECORDS = ALL_UNFOLDED_CAPABILITY_RECORDS.filter((record) => record.routing.parentTool === 'inspect');
-export function findByAction(action) {
-    const record = INSPECT_UNFOLDED_RECORDS.find((r) => r.legacyIds[0].action === action);
-    if (!record)
-        throw new Error(`Record not found for action: ${action}`);
-    return record;
-}
-//# sourceMappingURL=inspect-records.shared.js.map

package/dist/tools/catalog/capabilities/records/inspect/object-property.data.d.ts

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