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

package/dist/tools/catalog/capabilities/records/manage-blueprint/graph-pins.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-blueprint/graph-pins.js

@@ -1,153 +0,0 @@
-import { BP_PLUGINS, buildRecord } from './helpers.js';
-import { P } from './properties.js';
-const FAMILY = 'graph';
-const DOMAIN = 'blueprint';
-export const GRAPH_PINS_RECORDS = [
-    buildRecord({
-        id: 'blueprint.connect_pins',
-        action: 'connect_pins',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['link pins', 'wire nodes', 'connect nodes', 'exec pin', 'connect output to input'],
-        summary: 'Connect two graph pins (exec or data) by nodeGuid and pin name. A pin the editor adds on demand is added: a Sequence\'s then_2, a Make Array\'s [2], a Switch on Int\'s case 7 (a new switch has only Default).',
-        whenToUse: ['An exec or data link between two existing nodes must be created.'],
-        whenNotToUse: ['Links must be broken (use break_pin_links).'],
-        inputProps: { blueprintPath: P.blueprintPath, graphName: P.graphName, fromNodeId: P.fromNodeId, fromPinName: P.fromPinName, toNodeId: P.toNodeId, toPinName: P.toPinName, sourceNode: P.sourceNode, targetNode: P.targetNode, sourcePin: P.sourcePin, targetPin: P.targetPin },
-        required: ['blueprintPath', 'fromNodeId', 'fromPinName', 'toNodeId', 'toPinName'],
-        outputProps: {
-            connected: { type: 'boolean', description: 'Whether the two pins are linked after the call, read back from the graph rather than inferred from the schema call.' },
-            sourcePinName: { type: 'string', description: 'Source pin that was actually used — the first output pin when fromPinName named none.' },
-            targetPinName: { type: 'string', description: 'Target pin that was actually used.' },
-            sourcePinType: { type: 'string', description: 'Pin category of the source pin (exec, object, real, ...).' },
-            targetPinType: { type: 'string', description: 'Pin category of the target pin.' },
-            blueprintPath: { type: 'string', description: 'Normalized blueprint path the link was written to.' },
-            saved: { type: 'boolean', description: 'Whether the blueprint asset was saved after the link was made.' },
-            replacedLinks: {
-                type: 'array',
-                items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true },
-                'x-unreal-reflection-boundary': true,
-                description: 'Links the new one replaced, each {nodeId, nodeTitle, pinName}: a pin that holds one link (an exec output, a data input) drops its old link to take the new one. Absent when nothing was replaced.',
-            },
-        },
-        effect: 'write',
-        behavior: { idempotency: 'idempotent' },
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'connect_pins', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', fromNodeId: 'A1B2C3D4', fromPinName: 'OutExec', toNodeId: 'E5F6G7H8', toPinName: 'InExec' },
-        exampleOutput: { success: true, message: 'Pin connection complete', connected: true, sourcePinName: 'then', targetPinName: 'execute', sourcePinType: 'exec', targetPinType: 'exec', saved: true },
-    }),
-    buildRecord({
-        id: 'blueprint.break_pin_links',
-        action: 'break_pin_links',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Break all links from one pin on a graph node.',
-        whenToUse: ['All links from a specific pin must be removed.'],
-        whenNotToUse: ['A single link should be redirected (use connect_pins after breaking).'],
-        inputProps: { blueprintPath: P.blueprintPath, graphName: P.graphName, nodeId: P.nodeId, pinName: P.pinName, nodeGuid: P.nodeGuid },
-        required: ['blueprintPath', 'pinName'],
-        requiredOneOf: ['nodeId', 'nodeGuid'],
-        effect: 'destructive',
-        behavior: {},
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'break_pin_links', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', nodeId: 'A1B2C3D4', pinName: 'OutExec' },
-    }),
-    buildRecord({
-        id: 'blueprint.set_node_property',
-        action: 'set_node_property',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Set a property on a graph node by nodeGuid.',
-        whenToUse: ['A node-level property (e.g. comment, position) must be updated.'],
-        whenNotToUse: ['A pin default value is the target (use set_pin_default_value).'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, graphName: P.graphName, nodeId: P.nodeId, propertyName: P.propertyName, nodeGuid: P.nodeGuid,
-            propertyValue: { ...P.propertyValue, description: "set_node_property: text for NodeComment, a number for NodePosX or NodePosY, true or false for bCommentBubbleVisible or bDisabled, Enabled, Disabled or DevelopmentOnly for EnabledState, the text of a Math Expression node's Expression (each other name becomes an input pin, except one the Blueprint has a variable of, which reads that variable; a comparison used as a number is refused: write SelectFloat(1, 0, A > B)), an asset path for a reflected field. set_pin_default_value: the pin's new default as text: a number, true or false, an enum value name, a vector as X,Y,Z (0,150,110), a rotator as P,Y,R, or an asset path." },
-        },
-        required: ['blueprintPath', 'propertyName', 'propertyValue'],
-        requiredOneOf: ['nodeId', 'nodeGuid'],
-        outputProps: {
-            inputPins: { type: 'array', items: { type: 'string' }, description: 'Expression: the input pins the parsed expression made, the names to wire.' },
-            boundToMembers: { type: 'array', items: { type: 'string' }, description: 'Expression: names that read the Blueprint\'s own variable of that name instead of making a pin; rename the input to get a pin.' },
-        },
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'set_node_property', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', nodeId: 'A1B2C3D4', propertyName: 'NodeComment', propertyValue: 'Entry point' },
-    }),
-    buildRecord({
-        id: 'blueprint.set_pin_default_value',
-        action: 'set_pin_default_value',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Set the default value of a data pin on a graph node; a read-only (const reference) pin gets it through a MakeLiteral node wired into it.',
-        whenToUse: ['A pin\'s default literal value must be set when it has no incoming link.', 'A read-only text, string, name or number pin (TextRender Set Text\'s Value) needs a literal.'],
-        whenNotToUse: ['The pin should receive its value from a linked node (use connect_pins).'],
-        inputProps: { blueprintPath: P.blueprintPath, graphName: P.graphName, nodeId: P.nodeId, pinName: P.pinName, propertyValue: { ...P.propertyValue, description: "set_pin_default_value: the pin's new default as text: a number, true or false, an enum value name, a vector as X,Y,Z (0,150,110), a rotator as P,Y,R, or an asset path." }, nodeGuid: P.nodeGuid },
-        required: ['blueprintPath', 'pinName'],
-        requiredOneOf: ['nodeId', 'nodeGuid'],
-        outputProps: {
-            nodeId: P.nodeId, pinName: P.pinName,
-            appliedValue: { type: 'string', description: 'Literal actually stored on the pin (or the resolved object path for object/class pins).' },
-            literalNodeId: { type: 'string', description: 'Guid of the MakeLiteral node carrying the value when the pin itself takes no literal; setting the pin again updates that node.' },
-        },
-        effect: 'write',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'set_pin_default_value', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', nodeId: 'A1B2C3D4', pinName: 'InString', propertyValue: 'Hello' },
-        exampleOutput: { success: true, message: 'Pin default value set', nodeId: 'A1B2C3D4', pinName: 'InString', appliedValue: 'Hello' },
-    }),
-    buildRecord({
-        id: 'blueprint.arrange_nodes',
-        action: 'arrange_nodes',
-        family: FAMILY,
-        domain: DOMAIN,
-        topics: ['arrange nodes', 'tidy graph', 'clean up graph layout', 'move nodes next to each other', 'layout nodes'],
-        summary: 'Tidy a graph: move the listed nodes beside the nodes they are wired to (right of what runs them, below-left of what reads them), each to the nearest free slot; the nodes left out stay put and anchor them.',
-        whenToUse: ['Nodes of a chain sit far from each other or from the event they hang off, and should be laid out beside what they are wired to.'],
-        whenNotToUse: ['One node must go to an exact position (use set_node_property with NodePosX and NodePosY).', 'Every listed node is wired only to other listed nodes: nothing anchors them, so none moves; leave the head of the chain (its event) out of nodeIds.'],
-        inputProps: {
-            blueprintPath: P.blueprintPath, graphName: P.graphName,
-            nodeIds: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 500, description: 'The nodes to move, by nodeId or nodeGuid. Nodes left out stay where they are and anchor the ones listed; a node wired to nothing left in place goes back where it was and is listed under unmoved.' },
-        },
-        required: ['blueprintPath', 'nodeIds'],
-        outputProps: {
-            moved: { type: 'array', items: { type: 'object', additionalProperties: true, 'x-unreal-reflection-boundary': true }, description: 'Each node that moved: nodeId, nodeTitle and its new x and y.' },
-            unmoved: { type: 'array', items: { type: 'string' }, description: 'Ids of listed nodes that stayed where they were: wired to no node left in place, or no free slot near one.' },
-        },
-        outputRequired: [],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'arrange_nodes', blueprintPath: '/Game/Blueprints/BP_Test', graphName: 'EventGraph', nodeIds: ['A1B2C3D4', 'E5F6A7B8'] },
-        exampleOutput: { success: true, message: 'Moved 2 of 2 nodes beside the nodes they are wired to.', moved: [{ nodeId: 'A1B2C3D4', nodeTitle: 'Print String', x: 480, y: 0 }], unmoved: [] },
-    }),
-    buildRecord({
-        id: 'blueprint.add_construction_script',
-        action: 'add_construction_script',
-        family: FAMILY,
-        domain: DOMAIN,
-        summary: 'Add or open the Construction Script graph for a Blueprint.',
-        whenToUse: ['The Construction Script graph must be created or opened for editing.'],
-        whenNotToUse: ['An event graph is needed (use create_node in EventGraph).'],
-        inputProps: { blueprintPath: P.blueprintPath },
-        required: ['blueprintPath'],
-        outputProps: { graphName: P.graphName },
-        outputRequired: ['graphName'],
-        effect: 'write',
-        latency: 'interactive',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'add_construction_script', blueprintPath: '/Game/Blueprints/BP_Test' },
-        exampleOutput: { success: true, graphName: 'ConstructionScript' },
-    }),
-];
-//# sourceMappingURL=graph-pins.js.map

package/dist/tools/catalog/capabilities/records/manage-blueprint/helpers.d.ts

@@ -1,11 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-import { type CoreRecordSpec } from '../core/builder.js';
-export declare const BP_PLUGINS: string[];
-export declare const WIDGET_PLUGINS: string[];
-export type RecordSpec = Omit<CoreRecordSpec, 'parentTool' | 'bareInput' | 'costLatency' | 'costResources' | 'id'> & {
-    readonly id: string;
-    readonly latency: NonNullable<CoreRecordSpec['costLatency']>;
-    readonly resources: NonNullable<CoreRecordSpec['costResources']>;
-};
-export declare const buildRecord: ({ latency, resources, ...spec }: RecordSpec) => CapabilityRecordSource;
-//# sourceMappingURL=helpers.d.ts.map

package/dist/tools/catalog/capabilities/records/manage-blueprint/helpers.js

@@ -1,5 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-export const BP_PLUGINS = ['EditorScriptingUtilities'];
-export const WIDGET_PLUGINS = ['EditorScriptingUtilities', 'UMG'];
-export const buildRecord = ({ latency, resources, ...spec }) => buildCoreRecord({ ...spec, parentTool: 'manage_blueprint', plugins: spec.plugins ?? BP_PLUGINS, costLatency: latency, costResources: resources });
-//# sourceMappingURL=helpers.js.map

package/dist/tools/catalog/capabilities/records/manage-blueprint/index.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-blueprint/index.js

@@ -1,40 +0,0 @@
-import { BLUEPRINT_LIFECYCLE_RECORDS } from './blueprint-lifecycle.js';
-import { FUNCTIONS_EVENTS_RECORDS } from './functions-events.js';
-import { GRAPH_BATCH_RECORDS } from './graph-batch.js';
-import { GRAPH_NODES_RECORDS } from './graph-nodes.js';
-import { GRAPH_PINS_RECORDS } from './graph-pins.js';
-import { PROBE_RECORDS } from './probe.js';
-import { SCS_COMPONENTS_RECORDS } from './scs-components.js';
-import { VARIABLES_METADATA_RECORDS } from './variables-metadata.js';
-import { WIDGET_ANIMATION_RECORDS } from './widget-animation.js';
-import { WIDGET_BINDINGS_RECORDS } from './widget-bindings.js';
-import { WIDGET_CONTENT_RECORDS } from './widget-content.js';
-import { WIDGET_GAME_UI_RECORDS } from './widget-game-ui.js';
-import { WIDGET_INFO_RECORDS } from './widget-info.js';
-import { WIDGET_LAYOUT_RECORDS } from './widget-layout.js';
-import { WIDGET_LIFECYCLE_RECORDS } from './widget-lifecycle.js';
-import { WIDGET_PANELS_RECORDS } from './widget-panels.js';
-import { WIDGET_TEMPLATES_RECORDS } from './widget-templates.js';
-import { applyFolds } from '../shared/fold.js';
-import { MANAGE_BLUEPRINT_FOLDS } from '../folds/manage-blueprint.folds.js';
-export const MANAGE_BLUEPRINT_UNFOLDED_SOURCES = [
-    ...BLUEPRINT_LIFECYCLE_RECORDS,
-    ...SCS_COMPONENTS_RECORDS,
-    ...VARIABLES_METADATA_RECORDS,
-    ...GRAPH_NODES_RECORDS,
-    ...GRAPH_PINS_RECORDS,
-    ...GRAPH_BATCH_RECORDS,
-    ...FUNCTIONS_EVENTS_RECORDS,
-    ...PROBE_RECORDS,
-    ...WIDGET_LIFECYCLE_RECORDS,
-    ...WIDGET_PANELS_RECORDS,
-    ...WIDGET_CONTENT_RECORDS,
-    ...WIDGET_LAYOUT_RECORDS,
-    ...WIDGET_BINDINGS_RECORDS,
-    ...WIDGET_ANIMATION_RECORDS,
-    ...WIDGET_INFO_RECORDS,
-    ...WIDGET_GAME_UI_RECORDS,
-    ...WIDGET_TEMPLATES_RECORDS,
-];
-export const MANAGE_BLUEPRINT_SOURCES = applyFolds(MANAGE_BLUEPRINT_UNFOLDED_SOURCES, MANAGE_BLUEPRINT_FOLDS, 'manage_blueprint');
-//# sourceMappingURL=index.js.map

package/dist/tools/catalog/capabilities/records/manage-blueprint/probe.d.ts

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

package/dist/tools/catalog/capabilities/records/manage-blueprint/probe.js

@@ -1,30 +0,0 @@
-import { BP_PLUGINS, buildRecord } from './helpers.js';
-import { P } from './properties.js';
-export const PROBE_RECORDS = [
-    buildRecord({
-        id: 'blueprint.probe_handle',
-        action: 'probe_handle',
-        family: 'probe',
-        domain: 'blueprint',
-        summary: 'Probe a Blueprint handle for reachability without loading the asset; reports its asset class.',
-        whenToUse: ['A Blueprint handle must be validated before a sequence of operations.'],
-        whenNotToUse: ['Graph edits must be batched (use edit_graph with edit batch).'],
-        inputProps: { blueprintPath: P.blueprintPath },
-        required: ['blueprintPath'],
-        outputProps: {
-            reachable: { type: 'boolean', description: 'Whether the Blueprint handle is reachable.' },
-            exists: { type: 'boolean', description: 'Whether the asset exists.' },
-            path: { type: 'string', description: 'Normalized asset path that was checked.' },
-            assetClass: { type: 'string', description: 'Asset class from the registry, when it exists.' },
-        },
-        outputRequired: ['reachable'],
-        effect: 'read',
-        behavior: { idempotency: 'idempotent', safeToRetry: true },
-        latency: 'instant',
-        resources: 'low',
-        plugins: BP_PLUGINS,
-        exampleInput: { action: 'probe_handle', blueprintPath: '/Game/Blueprints/BP_Test' },
-        exampleOutput: { success: true, reachable: true, exists: true, path: '/Game/Blueprints/BP_Test', assetClass: 'Blueprint' },
-    }),
-];
-//# sourceMappingURL=probe.js.map