unreal-engine-mcp-server 0.4.7 → 0.5.1

package/dist/wasm/index.js

@@ -0,0 +1,535 @@
+import { Logger } from '../utils/logger.js';
+const isNodeEnvironment = typeof process !== 'undefined' &&
+    process.versions != null &&
+    process.versions.node != null;
+let nodeFileFetchPatched = false;
+async function ensureNodeFileFetchForWasm() {
+    if (!isNodeEnvironment || nodeFileFetchPatched) {
+        return;
+    }
+    const originalFetch = globalThis.fetch;
+    if (typeof originalFetch !== 'function') {
+        return;
+    }
+    try {
+        const fs = await import('node:fs/promises');
+        const url = await import('node:url');
+        const readFile = fs.readFile;
+        const fileURLToPath = url.fileURLToPath;
+        const toUrl = (input) => {
+            try {
+                if (input instanceof URL) {
+                    return input;
+                }
+                if (typeof input === 'string') {
+                    return new URL(input);
+                }
+                const RequestCtor = globalThis.Request;
+                if (RequestCtor && input instanceof RequestCtor && typeof input.url === 'string') {
+                    return new URL(input.url);
+                }
+            }
+            catch {
+            }
+            return null;
+        };
+        globalThis.fetch = (async (input, init) => {
+            try {
+                const target = toUrl(input);
+                if (target && target.protocol === 'file:') {
+                    const filePath = fileURLToPath(target);
+                    const data = await readFile(filePath);
+                    const buffer = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+                    return buffer;
+                }
+            }
+            catch {
+            }
+            return originalFetch(input, init);
+        });
+        nodeFileFetchPatched = true;
+    }
+    catch {
+    }
+}
+export class WASMIntegration {
+    log = new Logger('WASMIntegration');
+    module = null;
+    config;
+    metrics = [];
+    maxMetrics = 1000;
+    initialized = false;
+    moduleUnavailable = false;
+    constructor(config = {}) {
+        const envFlag = process.env.WASM_ENABLED;
+        const envEnabled = envFlag === undefined ? true : envFlag === 'true';
+        const here = new URL('.', import.meta.url);
+        const herePath = here.pathname.replace(/\\/g, '/');
+        const defaultUrl = herePath.includes('/dist/')
+            ? new URL('../../src/wasm/pkg/unreal_mcp_wasm.js', import.meta.url)
+            : new URL('./pkg/unreal_mcp_wasm.js', import.meta.url);
+        const defaultWasmPath = defaultUrl.href;
+        this.config = {
+            enabled: config.enabled ?? envEnabled,
+            wasmPath: config.wasmPath ?? process.env.WASM_PATH ?? defaultWasmPath,
+            fallbackEnabled: config.fallbackEnabled ?? true,
+            performanceMonitoring: config.performanceMonitoring ?? true
+        };
+    }
+    async initialize() {
+        if (this.initialized && this.module) {
+            this.log.debug('WASM module already initialized');
+            return;
+        }
+        if (this.moduleUnavailable) {
+            return;
+        }
+        if (!this.config.enabled) {
+            this.log.info('WASM integration is disabled');
+            return;
+        }
+        try {
+            this.log.info(`Loading WASM module from ${this.config.wasmPath}...`);
+            await ensureNodeFileFetchForWasm();
+            const wasmModule = await import(this.config.wasmPath);
+            await wasmModule.default();
+            this.module = wasmModule;
+            this.initialized = true;
+            this.log.info('✅ WebAssembly module initialized successfully');
+            this.log.debug('WASM module functions:', {
+                hasPropertyParser: typeof wasmModule.PropertyParser === 'function',
+                hasTransformCalculator: typeof wasmModule.TransformCalculator === 'function',
+                hasVector: typeof wasmModule.Vector === 'function',
+                hasUtils: typeof wasmModule.Utils === 'function'
+            });
+        }
+        catch (error) {
+            this.log.error('Failed to initialize WebAssembly module:', error);
+            const code = error?.code;
+            if (code === 'ERR_MODULE_NOT_FOUND') {
+                this.log.warn('WebAssembly module not found. To enable WASM, run "npm run build:wasm". To silence this warning, set WASM_ENABLED=false.');
+                this.moduleUnavailable = true;
+            }
+            this.log.warn('Falling back to TypeScript implementations');
+            if (!this.config.fallbackEnabled) {
+                throw new Error('WASM initialization failed and fallbacks are disabled');
+            }
+            this.module = null;
+            this.initialized = false;
+        }
+    }
+    isReady() {
+        return this.initialized && this.module !== null;
+    }
+    static isSupported() {
+        return typeof WebAssembly === 'object' &&
+            typeof WebAssembly.instantiate === 'function';
+    }
+    async parseProperties(jsonStr, options) {
+        const start = performance.now();
+        if (!this.isReady()) {
+            await this.initialize();
+        }
+        if (this.module && typeof this.module.PropertyParser === 'function') {
+            try {
+                const parser = new this.module.PropertyParser();
+                const result = parser.parse_properties(jsonStr, options?.maxDepth ?? 100);
+                const duration = performance.now() - start;
+                this.recordMetrics('parse_properties', duration, true);
+                return result;
+            }
+            catch (error) {
+                this.log.warn('WASM property parsing failed, falling back to TypeScript:', error);
+            }
+        }
+        const duration = performance.now() - start;
+        this.recordMetrics('parse_properties', duration, false);
+        return this.fallbackParseProperties(jsonStr);
+    }
+    composeTransform(location, rotation, scale) {
+        const start = performance.now();
+        if (this.isReady() && this.module && typeof this.module.TransformCalculator === 'function') {
+            try {
+                const calculator = new this.module.TransformCalculator();
+                const result = calculator.composeTransform(new Float32Array(location), new Float32Array(rotation), new Float32Array(scale));
+                const duration = performance.now() - start;
+                this.recordMetrics('compose_transform', duration, true);
+                return new Float32Array(result);
+            }
+            catch (error) {
+                this.log.warn('WASM transform calculation failed, falling back to TypeScript:', error);
+            }
+        }
+        const duration = performance.now() - start;
+        this.recordMetrics('compose_transform', duration, false);
+        return this.fallbackComposeTransform(location, rotation, scale);
+    }
+    decomposeMatrix(matrix) {
+        const start = performance.now();
+        if (this.isReady() && this.module && typeof this.module.TransformCalculator === 'function') {
+            try {
+                const calculator = new this.module.TransformCalculator();
+                const result = calculator.decomposeMatrix(matrix);
+                const duration = performance.now() - start;
+                this.recordMetrics('decompose_matrix', duration, true);
+                return Array.from(result);
+            }
+            catch (error) {
+                this.log.warn('WASM matrix decomposition failed, falling back to TypeScript:', error);
+            }
+        }
+        const duration = performance.now() - start;
+        this.recordMetrics('decompose_matrix', duration, false);
+        return this.fallbackDecomposeMatrix(matrix);
+    }
+    vectorAdd(v1, v2) {
+        const start = performance.now();
+        if (this.isReady() && this.module && typeof this.module.Vector === 'function') {
+            try {
+                const vec1 = new this.module.Vector(v1[0], v1[1], v1[2]);
+                const vec2 = new this.module.Vector(v2[0], v2[1], v2[2]);
+                const result = vec1.add(vec2);
+                const duration = performance.now() - start;
+                this.recordMetrics('vector_add', duration, true);
+                return [result.x, result.y, result.z];
+            }
+            catch (error) {
+                this.log.warn('WASM vector addition failed, falling back to TypeScript:', error);
+            }
+        }
+        const duration = performance.now() - start;
+        this.recordMetrics('vector_add', duration, false);
+        return this.fallbackVectorAdd(v1, v2);
+    }
+    async resolveDependencies(assetPath, dependencies, options) {
+        const start = performance.now();
+        if (!this.isReady()) {
+            await this.initialize();
+        }
+        if (this.module && typeof this.module.DependencyResolver === 'function') {
+            try {
+                const resolver = new this.module.DependencyResolver();
+                const dependenciesJson = JSON.stringify(dependencies);
+                const result = resolver.analyzeDependencies(assetPath, dependenciesJson, options?.maxDepth ?? 100);
+                const duration = performance.now() - start;
+                this.recordMetrics('resolve_dependencies', duration, true);
+                return result;
+            }
+            catch (error) {
+                this.log.warn('WASM dependency resolution failed, falling back to TypeScript:', error);
+            }
+        }
+        const duration = performance.now() - start;
+        this.recordMetrics('resolve_dependencies', duration, false);
+        return this.fallbackResolveDependencies(assetPath, dependencies, options);
+    }
+    async calculateDependencyDepth(assetPath, dependencies, options) {
+        const start = performance.now();
+        if (!this.isReady()) {
+            await this.initialize();
+        }
+        if (this.module && typeof this.module.DependencyResolver === 'function') {
+            try {
+                const resolver = new this.module.DependencyResolver();
+                const dependenciesJson = JSON.stringify(dependencies);
+                const result = resolver.calculateDepth(assetPath, dependenciesJson, options?.maxDepth ?? 100);
+                const duration = performance.now() - start;
+                this.recordMetrics('calculate_dependency_depth', duration, true);
+                return result;
+            }
+            catch (error) {
+                this.log.warn('WASM dependency depth calculation failed, falling back to TypeScript:', error);
+            }
+        }
+        const duration = performance.now() - start;
+        this.recordMetrics('calculate_dependency_depth', duration, false);
+        return this.fallbackCalculateDependencyDepth(assetPath, dependencies, options);
+    }
+    async findCircularDependencies(dependencies, options) {
+        const start = performance.now();
+        if (!this.isReady()) {
+            await this.initialize();
+        }
+        if (this.module && typeof this.module.DependencyResolver === 'function') {
+            try {
+                const resolver = new this.module.DependencyResolver();
+                const dependenciesJson = JSON.stringify(dependencies);
+                const result = resolver.findCircularDependencies(dependenciesJson, options?.maxDepth ?? 100);
+                const duration = performance.now() - start;
+                this.recordMetrics('find_circular_dependencies', duration, true);
+                return result;
+            }
+            catch (error) {
+                this.log.warn('WASM circular dependency detection failed, falling back to TypeScript:', error);
+            }
+        }
+        const duration = performance.now() - start;
+        this.recordMetrics('find_circular_dependencies', duration, false);
+        return this.fallbackFindCircularDependencies(dependencies, options);
+    }
+    async topologicalSort(dependencies) {
+        const start = performance.now();
+        if (!this.isReady()) {
+            await this.initialize();
+        }
+        if (this.module && typeof this.module.DependencyResolver === 'function') {
+            try {
+                const resolver = new this.module.DependencyResolver();
+                const dependenciesJson = JSON.stringify(dependencies);
+                const result = resolver.topologicalSort(dependenciesJson);
+                const duration = performance.now() - start;
+                this.recordMetrics('topological_sort', duration, true);
+                return result;
+            }
+            catch (error) {
+                this.log.warn('WASM topological sort failed, falling back to TypeScript:', error);
+            }
+        }
+        const duration = performance.now() - start;
+        this.recordMetrics('topological_sort', duration, false);
+        return this.fallbackTopologicalSort(dependencies);
+    }
+    getMetrics() {
+        const operations = this.metrics.slice(-this.maxMetrics);
+        const wasmOperations = operations.filter(m => m.useWASM).length;
+        const tsOperations = operations.filter(m => !m.useWASM).length;
+        const totalTime = operations.reduce((sum, m) => sum + m.duration, 0);
+        const averageTime = operations.length > 0 ? totalTime / operations.length : 0;
+        return {
+            totalOperations: operations.length,
+            wasmOperations,
+            tsOperations,
+            averageTime,
+            operations
+        };
+    }
+    getStatus() {
+        return {
+            enabled: this.config.enabled,
+            ready: this.isReady(),
+            moduleUnavailable: this.moduleUnavailable
+        };
+    }
+    clearMetrics() {
+        this.metrics = [];
+    }
+    reportPerformance() {
+        const metrics = this.getMetrics();
+        const wasmPercentage = metrics.totalOperations > 0
+            ? ((metrics.wasmOperations / metrics.totalOperations) * 100).toFixed(1)
+            : '0';
+        const report = [
+            '=== WASM Performance Report ===',
+            `Total Operations: ${metrics.totalOperations}`,
+            `WASM Operations: ${metrics.wasmOperations} (${wasmPercentage}%)`,
+            `TypeScript Operations: ${metrics.tsOperations}`,
+            `Average Time: ${metrics.averageTime.toFixed(2)}ms`,
+            '=============================='
+        ].join('\n');
+        return report;
+    }
+    recordMetrics(operation, duration, useWASM) {
+        if (!this.config.performanceMonitoring) {
+            return;
+        }
+        this.metrics.push({
+            operation,
+            duration,
+            timestamp: Date.now(),
+            useWASM
+        });
+        if (this.metrics.length > this.maxMetrics) {
+            this.metrics.shift();
+        }
+    }
+    fallbackParseProperties(jsonStr) {
+        try {
+            return JSON.parse(jsonStr);
+        }
+        catch (error) {
+            this.log.error('Failed to parse JSON:', error);
+            throw error;
+        }
+    }
+    fallbackComposeTransform(location, rotation, scale) {
+        const matrix = new Float32Array(16);
+        const [x, y, z] = location;
+        const [_pitch, _yaw, _roll] = rotation.map(angle => angle * Math.PI / 180);
+        const [sx, sy, sz] = scale;
+        matrix[0] = sx;
+        matrix[5] = sy;
+        matrix[10] = sz;
+        matrix[12] = x;
+        matrix[13] = y;
+        matrix[14] = z;
+        matrix[15] = 1;
+        return matrix;
+    }
+    fallbackDecomposeMatrix(matrix) {
+        const location = [matrix[12], matrix[13], matrix[14]];
+        const scale = [
+            Math.sqrt(matrix[0] * matrix[0] + matrix[1] * matrix[1] + matrix[2] * matrix[2]),
+            Math.sqrt(matrix[4] * matrix[4] + matrix[5] * matrix[5] + matrix[6] * matrix[6]),
+            Math.sqrt(matrix[8] * matrix[8] + matrix[9] * matrix[9] + matrix[10] * matrix[10])
+        ];
+        const rotation = [0, 0, 0];
+        return [...location, ...rotation, ...scale];
+    }
+    fallbackVectorAdd(v1, v2) {
+        return [
+            v1[0] + v2[0],
+            v1[1] + v2[1],
+            v1[2] + v2[2]
+        ];
+    }
+    fallbackResolveDependencies(assetPath, dependencies, options) {
+        const maxDepth = options?.maxDepth ?? 100;
+        const visited = new Set();
+        const result = [];
+        const queue = [
+            { path: assetPath, depth: 0 }
+        ];
+        while (queue.length > 0) {
+            const item = queue.shift();
+            if (!item)
+                continue;
+            const { path, depth } = item;
+            if (depth > maxDepth || visited.has(path)) {
+                continue;
+            }
+            visited.add(path);
+            if (dependencies[path]) {
+                result.push({
+                    path,
+                    dependencies: dependencies[path],
+                    depth
+                });
+                for (const dep of dependencies[path]) {
+                    queue.push({ path: dep, depth: depth + 1 });
+                }
+            }
+        }
+        const totalCount = result.length;
+        return {
+            asset: assetPath,
+            dependencies: result,
+            total_dependency_count: totalCount,
+            max_depth: maxDepth,
+            analysis_time_ms: 0,
+            totalDependencyCount: totalCount,
+            maxDepth,
+            analysisTimeMs: 0,
+            circular_dependencies: [],
+            circularDependencies: []
+        };
+    }
+    fallbackCalculateDependencyDepth(assetPath, dependencies, options) {
+        const maxDepth = options?.maxDepth ?? 100;
+        const visited = new Set();
+        const dfs = (path, depthRemaining) => {
+            if (visited.has(path) || depthRemaining === 0) {
+                return 0;
+            }
+            visited.add(path);
+            const deps = dependencies[path] || [];
+            if (!deps.length) {
+                visited.delete(path);
+                return 0;
+            }
+            let maxChildDepth = 0;
+            for (const dep of deps) {
+                const childDepth = dfs(dep, depthRemaining - 1);
+                if (childDepth > maxChildDepth) {
+                    maxChildDepth = childDepth;
+                }
+            }
+            visited.delete(path);
+            return maxChildDepth + 1;
+        };
+        return dfs(assetPath, maxDepth);
+    }
+    fallbackFindCircularDependencies(dependencies, options) {
+        const maxDepth = options?.maxDepth ?? 100;
+        const cycles = [];
+        const visited = new Set();
+        const stack = new Set();
+        const dfs = (current, depth, path) => {
+            if (depth > maxDepth) {
+                return;
+            }
+            visited.add(current);
+            stack.add(current);
+            path.push(current);
+            const deps = dependencies[current] || [];
+            for (const dep of deps) {
+                if (!visited.has(dep)) {
+                    dfs(dep, depth + 1, path);
+                }
+                else if (stack.has(dep)) {
+                    const startIndex = path.indexOf(dep);
+                    if (startIndex !== -1) {
+                        cycles.push(path.slice(startIndex));
+                    }
+                }
+            }
+            stack.delete(current);
+            path.pop();
+        };
+        for (const asset of Object.keys(dependencies)) {
+            if (!visited.has(asset)) {
+                dfs(asset, 0, []);
+            }
+        }
+        return cycles;
+    }
+    fallbackTopologicalSort(dependencies) {
+        const inDegree = new Map();
+        const graph = new Map();
+        for (const [asset, deps] of Object.entries(dependencies)) {
+            if (!inDegree.has(asset)) {
+                inDegree.set(asset, 0);
+            }
+            for (const dep of deps) {
+                if (!inDegree.has(dep)) {
+                    inDegree.set(dep, 0);
+                }
+                const list = graph.get(dep) || [];
+                list.push(asset);
+                graph.set(dep, list);
+            }
+        }
+        const queue = [];
+        for (const [asset, degree] of inDegree.entries()) {
+            if (degree === 0) {
+                queue.push(asset);
+            }
+        }
+        const sorted = [];
+        while (queue.length > 0) {
+            const asset = queue.shift();
+            sorted.push(asset);
+            const dependents = graph.get(asset) || [];
+            for (const dependent of dependents) {
+                const current = inDegree.get(dependent) ?? 0;
+                const next = current - 1;
+                inDegree.set(dependent, next);
+                if (next === 0) {
+                    queue.push(dependent);
+                }
+            }
+        }
+        return sorted;
+    }
+}
+export const wasmIntegration = new WASMIntegration();
+export async function initializeWASM(config) {
+    const integration = config ? new WASMIntegration(config) : wasmIntegration;
+    await integration.initialize();
+}
+export function isWASMReady() {
+    return wasmIntegration.isReady();
+}
+export function getWASMPerformanceReport() {
+    return wasmIntegration.reportPerformance();
+}
+//# sourceMappingURL=index.js.map