unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/graphql/loaders.d.ts

@@ -0,0 +1,64 @@
+import DataLoader from 'dataloader';
+import type { AutomationBridge } from '../automation/index.js';
+export interface Actor {
+    name: string;
+    label?: string;
+    class?: string;
+    path?: string;
+    location?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation?: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    };
+    scale?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    tags?: string[];
+}
+export interface Asset {
+    name: string;
+    path: string;
+    class?: string;
+    packagePath?: string;
+    size?: number;
+}
+export interface Blueprint {
+    name: string;
+    path: string;
+    parentClass?: string;
+    variables?: Array<{
+        name: string;
+        type: string;
+        defaultValue?: unknown;
+    }>;
+    functions?: Array<{
+        name: string;
+        parameters?: Array<{
+            name: string;
+            type: string;
+        }>;
+    }>;
+    components?: Array<{
+        name: string;
+        type: string;
+    }>;
+}
+export interface GraphQLLoaders {
+    actorLoader: DataLoader<string, Actor | null>;
+    assetLoader: DataLoader<string, Asset | null>;
+    blueprintLoader: DataLoader<string, Blueprint | null>;
+    actorComponentsLoader: DataLoader<string, Array<{
+        name: string;
+        type: string;
+    }> | null>;
+}
+export declare function createLoaders(automationBridge: AutomationBridge): GraphQLLoaders;
+export declare function clearLoaders(loaders: GraphQLLoaders): void;
+//# sourceMappingURL=loaders.d.ts.map

package/dist/graphql/loaders.js

@@ -0,0 +1,117 @@
+import DataLoader from 'dataloader';
+import { Logger } from '../utils/logger.js';
+const log = new Logger('GraphQL:Loaders');
+export function createLoaders(automationBridge) {
+    return {
+        actorLoader: new DataLoader(async (names) => {
+            log.debug(`Batching actor fetch for ${names.length} actors`);
+            try {
+                const result = await automationBridge.sendAutomationRequest('control_actor', {
+                    action: 'batch_get',
+                    actorNames: [...names]
+                });
+                if (result.success && result.actors) {
+                    return names.map(name => result.actors?.find(a => a.name === name || a.label === name) ?? null);
+                }
+            }
+            catch {
+                log.debug('Batch fetch not supported, falling back to individual fetches');
+            }
+            const results = await Promise.all(names.map(async (name) => {
+                try {
+                    const result = await automationBridge.sendAutomationRequest('control_actor', {
+                        action: 'find_by_name',
+                        actorName: name
+                    });
+                    return result.success ? (result.actor ?? null) : null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            return results;
+        }, {
+            cache: true,
+            maxBatchSize: 50
+        }),
+        assetLoader: new DataLoader(async (paths) => {
+            log.debug(`Batching asset fetch for ${paths.length} assets`);
+            try {
+                const result = await automationBridge.sendAutomationRequest('manage_asset', {
+                    action: 'batch_get',
+                    assetPaths: [...paths]
+                });
+                if (result.success && result.assets) {
+                    return paths.map(path => result.assets?.find(a => a.path === path) ?? null);
+                }
+            }
+            catch {
+                log.debug('Batch asset fetch not supported');
+            }
+            const results = await Promise.all(paths.map(async (path) => {
+                try {
+                    const result = await automationBridge.sendAutomationRequest('manage_asset', {
+                        action: 'exists',
+                        assetPath: path
+                    });
+                    if (result.success && result.exists) {
+                        return result.asset ?? { name: path.split('/').pop() || '', path };
+                    }
+                    return null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            return results;
+        }, {
+            cache: true,
+            maxBatchSize: 100
+        }),
+        blueprintLoader: new DataLoader(async (paths) => {
+            log.debug(`Batching blueprint fetch for ${paths.length} blueprints`);
+            const results = await Promise.all(paths.map(async (path) => {
+                try {
+                    const result = await automationBridge.sendAutomationRequest('manage_blueprint', {
+                        action: 'get_blueprint',
+                        blueprintPath: path
+                    });
+                    return result.success ? (result.blueprint ?? null) : null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            return results;
+        }, {
+            cache: true,
+            maxBatchSize: 20
+        }),
+        actorComponentsLoader: new DataLoader(async (actorNames) => {
+            log.debug(`Batching component fetch for ${actorNames.length} actors`);
+            const results = await Promise.all(actorNames.map(async (actorName) => {
+                try {
+                    const result = await automationBridge.sendAutomationRequest('control_actor', {
+                        action: 'get_components',
+                        actorName
+                    });
+                    return result.success ? (result.components ?? null) : null;
+                }
+                catch {
+                    return null;
+                }
+            }));
+            return results;
+        }, {
+            cache: true,
+            maxBatchSize: 30
+        })
+    };
+}
+export function clearLoaders(loaders) {
+    loaders.actorLoader.clearAll();
+    loaders.assetLoader.clearAll();
+    loaders.blueprintLoader.clearAll();
+    loaders.actorComponentsLoader.clearAll();
+}
+//# sourceMappingURL=loaders.js.map

package/dist/graphql/resolvers.d.ts

@@ -0,0 +1,268 @@
+import type { GraphQLContext } from './types.js';
+export declare const scalarResolvers: {
+    Vector: {
+        serialize: (value: any) => any;
+        parseValue: (value: any) => any;
+        parseLiteral: (ast: any) => any;
+    };
+    Rotator: {
+        serialize: (value: any) => any;
+        parseValue: (value: any) => any;
+        parseLiteral: (ast: any) => any;
+    };
+    Transform: {
+        serialize: (value: any) => any;
+        parseValue: (value: any) => any;
+        parseLiteral: (ast: any) => any;
+    };
+    JSON: {
+        serialize: (value: any) => any;
+        parseValue: (value: any) => any;
+        parseLiteral: (ast: any) => any;
+    };
+};
+interface Asset {
+    name: string;
+    path: string;
+    class: string;
+    packagePath: string;
+    size?: number;
+    metadata?: Record<string, any>;
+    tags?: string[];
+}
+interface Actor {
+    name: string;
+    class: string;
+    location?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    rotation?: {
+        pitch: number;
+        yaw: number;
+        roll: number;
+    };
+    scale?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    tags?: string[];
+    properties?: Record<string, any>;
+}
+interface Blueprint {
+    name: string;
+    path: string;
+    parentClass?: string;
+    variables?: Array<{
+        name: string;
+        type: string;
+        defaultValue?: any;
+        metadata?: Record<string, any>;
+    }>;
+    functions?: Array<{
+        name: string;
+        inputs?: Array<{
+            name: string;
+            type: string;
+        }>;
+        outputs?: Array<{
+            name: string;
+            type: string;
+        }>;
+    }>;
+    events?: Array<{
+        name: string;
+        type: string;
+    }>;
+    components?: Array<{
+        name: string;
+        type: string;
+        properties?: Record<string, any>;
+    }>;
+    scsHierarchy?: Record<string, any>;
+}
+export declare const resolvers: {
+    Query: {
+        assets: (_: any, args: any, context: GraphQLContext) => Promise<{
+            edges: {
+                node: Asset;
+                cursor: string;
+            }[];
+            pageInfo: {
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+                startCursor: string | null;
+                endCursor: string | null;
+            };
+            totalCount: number;
+        }>;
+        asset: (_: any, { path }: {
+            path: string;
+        }, context: GraphQLContext) => Promise<import("./loaders.js").Asset | null>;
+        actors: (_: any, args: any, context: GraphQLContext) => Promise<{
+            edges: {
+                node: Actor;
+                cursor: string;
+            }[];
+            pageInfo: {
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+                startCursor: string | null;
+                endCursor: string | null;
+            };
+            totalCount: number;
+        }>;
+        actor: (_: any, { name }: {
+            name: string;
+        }, context: GraphQLContext) => Promise<import("./loaders.js").Actor | null>;
+        blueprints: (_: any, args: any, context: GraphQLContext) => Promise<{
+            edges: {
+                node: Blueprint;
+                cursor: string;
+            }[];
+            pageInfo: {
+                hasNextPage: number | true;
+                hasPreviousPage: boolean;
+                startCursor: string | null;
+                endCursor: string | null;
+            };
+            totalCount: number;
+        } | {
+            edges: never[];
+            pageInfo: {
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+                startCursor: null;
+                endCursor: null;
+            };
+            totalCount: number;
+        }>;
+        blueprint: (_: any, { path }: {
+            path: string;
+        }, context: GraphQLContext) => Promise<import("./loaders.js").Blueprint | null>;
+        levels: (_: any, __: any, context: GraphQLContext) => Promise<any>;
+        currentLevel: (_: any, __: any, context: GraphQLContext) => Promise<{} | null>;
+        materials: (_: any, args: any, context: GraphQLContext) => Promise<{
+            edges: {
+                node: Asset;
+                cursor: string;
+            }[];
+            pageInfo: {
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+                startCursor: string | null;
+                endCursor: string | null;
+            };
+            totalCount: number;
+        }>;
+        sequences: (_: any, args: any, context: GraphQLContext) => Promise<{
+            edges: {
+                node: Asset;
+                cursor: string;
+            }[];
+            pageInfo: {
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+                startCursor: string | null;
+                endCursor: string | null;
+            };
+            totalCount: number;
+        }>;
+        worldPartitionCells: (_: any, __: any, context: GraphQLContext) => Promise<any>;
+        niagaraSystems: (_: any, args: any, context: GraphQLContext) => Promise<{
+            edges: {
+                node: {
+                    emitters: never[];
+                    parameters: never[];
+                    name: string;
+                    path: string;
+                    class: string;
+                    packagePath: string;
+                    size?: number;
+                    metadata?: Record<string, any>;
+                    tags?: string[];
+                };
+                cursor: string;
+            }[];
+            pageInfo: {
+                hasNextPage: boolean;
+                hasPreviousPage: boolean;
+                startCursor: string | null;
+                endCursor: string | null;
+            };
+            totalCount: number;
+        }>;
+        niagaraSystem: (_: any, { path }: {
+            path: string;
+        }, context: GraphQLContext) => Promise<any>;
+        search: (_: any, { query, type }: any, context: GraphQLContext) => Promise<any>;
+    };
+    Mutation: {
+        duplicateAsset: (_: any, { path, newName }: any, context: GraphQLContext) => Promise<{}>;
+        moveAsset: (_: any, { path, newPath }: any, context: GraphQLContext) => Promise<{}>;
+        deleteAsset: (_: any, { path }: {
+            path: string;
+        }, context: GraphQLContext) => Promise<boolean>;
+        spawnActor: (_: any, { input }: any, context: GraphQLContext) => Promise<{}>;
+        deleteActor: (_: any, { name }: {
+            name: string;
+        }, context: GraphQLContext) => Promise<boolean>;
+        setActorTransform: (_: any, { name, transform }: any, context: GraphQLContext) => Promise<{}>;
+        createBlueprint: (_: any, { input }: any, context: GraphQLContext) => Promise<{}>;
+        addVariableToBlueprint: (_: any, { path, input }: any, context: GraphQLContext) => Promise<{}>;
+        addFunctionToBlueprint: (_: any, { path, input }: any, context: GraphQLContext) => Promise<{}>;
+        loadLevel: (_: any, { path }: {
+            path: string;
+        }, context: GraphQLContext) => Promise<{}>;
+        saveLevel: (_: any, { path }: {
+            path?: string;
+        }, context: GraphQLContext) => Promise<boolean>;
+        createMaterialInstance: (_: any, { parentPath, name, parameters }: any, context: GraphQLContext) => Promise<{}>;
+    };
+    Asset: {
+        dependencies: (parent: Asset, _: any, context: GraphQLContext) => Promise<any>;
+        dependents: (parent: Asset, _: any, context: GraphQLContext) => Promise<any>;
+    };
+    Actor: {
+        properties: (parent: Actor, _: any, context: GraphQLContext) => Promise<Record<string, any>>;
+        components: (parent: Actor, _: any, context: GraphQLContext) => Promise<any>;
+    };
+    Blueprint: {
+        variables: (parent: Blueprint, _args: any, _context: GraphQLContext) => Promise<{
+            name: string;
+            type: string;
+            defaultValue?: any;
+            metadata?: Record<string, any>;
+        }[]>;
+        functions: (parent: Blueprint, _args: any, _context: GraphQLContext) => Promise<{
+            name: string;
+            inputs?: Array<{
+                name: string;
+                type: string;
+            }>;
+            outputs?: Array<{
+                name: string;
+                type: string;
+            }>;
+        }[]>;
+        events: (parent: Blueprint, _args: any, _context: GraphQLContext) => Promise<{
+            name: string;
+            type: string;
+        }[]>;
+        components: (parent: Blueprint, _args: any, _context: GraphQLContext) => Promise<{
+            name: string;
+            type: string;
+            properties?: Record<string, any>;
+        }[]>;
+    };
+    Material: {
+        parameters: (parent: any, _: any, context: GraphQLContext) => Promise<any>;
+    };
+    Sequence: {
+        tracks: (parent: any, _: any, context: GraphQLContext) => Promise<any>;
+    };
+};
+export {};
+//# sourceMappingURL=resolvers.d.ts.map