@holoscript/core 1.0.0-alpha.1 → 2.0.0

package/src/HoloScriptParser.js

@@ -0,0 +1,338 @@
+/**
+ * HoloScript Parser
+ *
+ * Parses voice commands, gestures, and code into HoloScript AST.
+ * Supports both 3D VR and 2D UI elements.
+ */
+import { logger } from './logger';
+import { HoloScript2DParser } from './HoloScript2DParser';
+const HOLOSCRIPT_SECURITY_CONFIG = {
+    maxCommandLength: 1000,
+    maxTokens: 100,
+    maxHologramsPerUser: 50,
+    suspiciousKeywords: [
+        'process', 'require', 'eval', 'import', 'constructor',
+        'prototype', '__proto__', 'fs', 'child_process', 'exec',
+        'spawn', 'fetch', 'xmlhttprequest',
+    ],
+    allowedShapes: ['orb', 'cube', 'cylinder', 'pyramid', 'sphere', 'function', 'gate', 'stream'],
+    allowedUIElements: [
+        'canvas', 'button', 'textinput', 'panel', 'text', 'image',
+        'list', 'modal', 'slider', 'toggle', 'dropdown',
+        'flex-container', 'grid-container', 'scroll-view'
+    ],
+};
+export class HoloScriptParser {
+    constructor() {
+        this.ast = [];
+        this.parser2D = new HoloScript2DParser();
+    }
+    /**
+     * Parse voice command into AST nodes
+     */
+    parseVoiceCommand(command) {
+        if (command.command.length > HOLOSCRIPT_SECURITY_CONFIG.maxCommandLength) {
+            logger.warn('Command too long', {
+                length: command.command.length,
+                limit: HOLOSCRIPT_SECURITY_CONFIG.maxCommandLength,
+            });
+            return [];
+        }
+        const rawTokens = this.tokenizeCommand(command.command.toLowerCase());
+        const tokens = this.sanitizeTokens(rawTokens);
+        if (tokens.length === 0)
+            return [];
+        if (tokens.length > HOLOSCRIPT_SECURITY_CONFIG.maxTokens) {
+            logger.warn('Too many tokens in command', {
+                tokenCount: tokens.length,
+                limit: HOLOSCRIPT_SECURITY_CONFIG.maxTokens,
+            });
+            return [];
+        }
+        const commandType = tokens[0];
+        // Check if this is a 2D UI command
+        if ((commandType === 'create' || commandType === 'add') && tokens.length > 1) {
+            const elementType = tokens[1];
+            if (HOLOSCRIPT_SECURITY_CONFIG.allowedUIElements.includes(elementType)) {
+                return this.parse2DUICommand(command.command);
+            }
+        }
+        switch (commandType) {
+            case 'create':
+            case 'summon':
+                return this.parseCreateCommand(tokens.slice(1), command.spatialContext);
+            case 'connect':
+                return this.parseConnectCommand(tokens.slice(1));
+            case 'execute':
+            case 'run':
+                return this.parseExecuteCommand(tokens.slice(1));
+            case 'debug':
+                return this.parseDebugCommand(tokens.slice(1));
+            case 'visualize':
+                return this.parseVisualizeCommand(tokens.slice(1));
+            default:
+                return this.parseGenericCommand(tokens);
+        }
+    }
+    parse2DUICommand(command) {
+        const ui2DNode = this.parser2D.parse2DVoiceCommand(command);
+        if (!ui2DNode)
+            return [];
+        const astNode = {
+            type: '2d-ui',
+            uiElementType: ui2DNode.elementType,
+            name: ui2DNode.name,
+            properties: ui2DNode.properties,
+            events: ui2DNode.events,
+            children: ui2DNode.children,
+        };
+        return [astNode];
+    }
+    /**
+     * Parse gesture input
+     */
+    parseGesture(gesture) {
+        switch (gesture.type) {
+            case 'pinch':
+                return this.parsePinchGesture(gesture);
+            case 'swipe':
+                return this.parseSwipeGesture(gesture);
+            case 'rotate':
+                return this.parseRotateGesture(gesture);
+            case 'grab':
+                return this.parseGrabGesture(gesture);
+            default:
+                return [];
+        }
+    }
+    parseCreateCommand(tokens, position) {
+        if (tokens.length < 2)
+            return [];
+        const shape = tokens[0];
+        const name = tokens[1];
+        switch (shape) {
+            case 'orb':
+            case 'sphere':
+                return [this.createOrbNode(name, position)];
+            case 'function':
+                return [this.createFunctionNode(name, tokens.slice(2), position)];
+            case 'gate':
+                return [this.createGateNode(name, tokens.slice(2), position)];
+            case 'stream':
+                return [this.createStreamNode(name, tokens.slice(2), position)];
+            default:
+                return [this.createGenericNode(shape, name, position)];
+        }
+    }
+    parseConnectCommand(tokens) {
+        if (tokens.length < 3)
+            return [];
+        const from = tokens[0];
+        const to = tokens[2];
+        const dataType = tokens.length > 3 ? tokens[3] : 'any';
+        return [{
+                type: 'connection',
+                from,
+                to,
+                dataType,
+                bidirectional: tokens.includes('bidirectional') || tokens.includes('both'),
+            }];
+    }
+    createOrbNode(name, position) {
+        return {
+            type: 'orb',
+            name,
+            position: position || { x: 0, y: 0, z: 0 },
+            hologram: {
+                shape: 'orb',
+                color: '#00ffff',
+                size: 1,
+                glow: true,
+                interactive: true,
+            },
+            properties: {},
+            methods: [],
+        };
+    }
+    createFunctionNode(name, params, position) {
+        const parameters = [];
+        let inParams = false;
+        for (const param of params) {
+            if (param === 'with' || param === 'parameters') {
+                inParams = true;
+                continue;
+            }
+            if (inParams && param !== 'do' && param !== 'execute') {
+                parameters.push({
+                    type: 'parameter',
+                    name: param,
+                    dataType: 'any',
+                });
+            }
+        }
+        return {
+            type: 'function',
+            name,
+            parameters,
+            body: [],
+            position: position || { x: 0, y: 0, z: 0 },
+            hologram: {
+                shape: 'cube',
+                color: '#ff6b35',
+                size: 1.5,
+                glow: true,
+                interactive: true,
+            },
+        };
+    }
+    createGateNode(_name, params, position) {
+        const condition = params.join(' ').replace('condition', '').trim();
+        return {
+            type: 'gate',
+            condition,
+            truePath: [],
+            falsePath: [],
+            position: position || { x: 0, y: 0, z: 0 },
+            hologram: {
+                shape: 'pyramid',
+                color: '#4ecdc4',
+                size: 1,
+                glow: true,
+                interactive: true,
+            },
+        };
+    }
+    createStreamNode(name, params, position) {
+        return {
+            type: 'stream',
+            name,
+            source: params[0] || 'unknown',
+            transformations: [],
+            position: position || { x: 0, y: 0, z: 0 },
+            hologram: {
+                shape: 'cylinder',
+                color: '#45b7d1',
+                size: 2,
+                glow: true,
+                interactive: true,
+            },
+        };
+    }
+    createGenericNode(shape, name, position) {
+        return {
+            type: shape,
+            name,
+            position: position || { x: 0, y: 0, z: 0 },
+            hologram: {
+                shape: shape,
+                color: '#ffffff',
+                size: 1,
+                glow: false,
+                interactive: true,
+            },
+        };
+    }
+    parsePinchGesture(gesture) {
+        return [{
+                type: 'create',
+                position: gesture.position,
+                hologram: { shape: 'orb', color: '#ff0000', size: 0.5, glow: true, interactive: true },
+            }];
+    }
+    parseSwipeGesture(gesture) {
+        if (!gesture.direction)
+            return [];
+        return [{
+                type: 'connect',
+                position: gesture.position,
+                hologram: { shape: 'cylinder', color: '#00ff00', size: gesture.magnitude, glow: true, interactive: false },
+            }];
+    }
+    parseRotateGesture(gesture) {
+        return [{
+                type: 'modify',
+                position: gesture.position,
+                hologram: { shape: 'sphere', color: '#ffff00', size: 0.8, glow: true, interactive: true },
+            }];
+    }
+    parseGrabGesture(gesture) {
+        return [{
+                type: 'select',
+                position: gesture.position,
+                hologram: { shape: 'cube', color: '#ff00ff', size: 0.3, glow: true, interactive: true },
+            }];
+    }
+    tokenizeCommand(command) {
+        return command
+            .toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter(token => token.length > 0);
+    }
+    sanitizeTokens(tokens) {
+        return tokens.filter(token => {
+            const isSuspicious = HOLOSCRIPT_SECURITY_CONFIG.suspiciousKeywords.some(keyword => token.includes(keyword));
+            if (isSuspicious) {
+                logger.warn('Suspicious token blocked', { token });
+                return false;
+            }
+            return true;
+        });
+    }
+    parseExecuteCommand(tokens) {
+        return [{
+                type: 'execute',
+                target: tokens[0] || 'unknown',
+                hologram: { shape: 'sphere', color: '#ff4500', size: 1.2, glow: true, interactive: false },
+            }];
+    }
+    parseDebugCommand(tokens) {
+        return [{
+                type: 'debug',
+                target: tokens[0] || 'program',
+                hologram: { shape: 'pyramid', color: '#ff1493', size: 0.8, glow: true, interactive: true },
+            }];
+    }
+    parseVisualizeCommand(tokens) {
+        return [{
+                type: 'visualize',
+                target: tokens[0] || 'data',
+                hologram: { shape: 'cylinder', color: '#32cd32', size: 1.5, glow: true, interactive: true },
+            }];
+    }
+    parseGenericCommand(tokens) {
+        return [{
+                type: 'generic',
+                command: tokens.join(' '),
+                hologram: { shape: 'orb', color: '#808080', size: 0.5, glow: false, interactive: true },
+            }];
+    }
+    getAST() {
+        return [...this.ast];
+    }
+    addNode(node) {
+        this.ast.push(node);
+    }
+    clear() {
+        this.ast = [];
+    }
+    findNode(name) {
+        return this.ast.find(node => 'name' in node && node.name === name) || null;
+    }
+    getNodesAtPosition(position, radius = 1) {
+        return this.ast.filter(node => {
+            if (!node.position)
+                return false;
+            const distance = Math.sqrt(Math.pow(node.position.x - position.x, 2) +
+                Math.pow(node.position.y - position.y, 2) +
+                Math.pow(node.position.z - position.z, 2));
+            return distance <= radius;
+        });
+    }
+    parse2DCode(code) {
+        return this.parser2D.parse2DElement(code);
+    }
+    get2DParser() {
+        return this.parser2D;
+    }
+}

package/src/HoloScriptPlusParser.js

@@ -0,0 +1,371 @@
+/**
+ * HoloScriptPlus Parser - Extended DSL with Trait Annotations
+ *
+ * Extends HoloScript with support for:
+ * - @material trait annotations for PBR materials
+ * - @lighting trait annotations for dynamic lighting
+ * - @rendering trait annotations for GPU optimization
+ *
+ * Syntax:
+ * orb#sphere {
+ *   @material { type: pbr, metallic: 0.5, roughness: 0.4 }
+ *   @lighting { preset: studio, shadows: true }
+ *   @rendering { quality: high, lod: true }
+ * }
+ */
+import { HoloScriptCodeParser } from './HoloScriptCodeParser';
+// ============================================================================
+// HoloScriptPlus Parser
+// ============================================================================
+export class HoloScriptPlusParser {
+    constructor() {
+        this.baseParser = new HoloScriptCodeParser();
+    }
+    /**
+     * Parse HoloScript+ code with trait annotations
+     */
+    parse(code) {
+        // First, parse with base parser
+        const baseResult = this.baseParser.parse(code);
+        const ast = (Array.isArray(baseResult) ? baseResult : [baseResult]);
+        // Then enhance with trait annotations
+        return this.enhanceWithTraits(ast, code);
+    }
+    /**
+     * Enhance AST nodes with trait annotations
+     */
+    enhanceWithTraits(ast, code) {
+        return ast.map((node) => {
+            if (node.type === 'orb') {
+                return this.enhanceOrbNodeWithTraits(node, code);
+            }
+            return node;
+        });
+    }
+    /**
+     * Enhance OrbNode with trait annotations
+     */
+    enhanceOrbNodeWithTraits(node, code) {
+        const orbNode = node;
+        const enhanced = {
+            ...orbNode,
+            traits: [],
+            graphics: {},
+        };
+        // Find trait annotations in the code near this node
+        const traits = this.extractTraitAnnotations(code, node.line);
+        enhanced.traits = traits;
+        // Build graphics configuration from traits
+        if (traits.length > 0) {
+            enhanced.graphics = this.buildGraphicsConfig(traits);
+        }
+        return enhanced;
+    }
+    /**
+     * Extract trait annotations from code
+     */
+    extractTraitAnnotations(code, _orbLine) {
+        const traits = [];
+        const traitRegex = /@(material|lighting|rendering)\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/g;
+        let match;
+        while ((match = traitRegex.exec(code)) !== null) {
+            const type = match[1];
+            const configStr = match[2];
+            try {
+                const config = this.parseObjectLiteral(configStr);
+                switch (type) {
+                    case 'material':
+                        traits.push({
+                            type: 'material',
+                            config: config,
+                        });
+                        break;
+                    case 'lighting':
+                        traits.push({
+                            type: 'lighting',
+                            config: config,
+                        });
+                        break;
+                    case 'rendering':
+                        traits.push({
+                            type: 'rendering',
+                            config: config,
+                        });
+                        break;
+                }
+            }
+            catch (e) {
+                console.warn(`Failed to parse ${type} trait annotation:`, e);
+            }
+        }
+        return traits;
+    }
+    /**
+     * Parse object literal from string
+     * Supports nested objects and arrays
+     */
+    parseObjectLiteral(str) {
+        const config = {};
+        // Split by comma, but respect nested braces and brackets
+        let depth = 0;
+        let current = '';
+        let pairs = [];
+        for (let i = 0; i < str.length; i++) {
+            const char = str[i];
+            if (char === '{' || char === '[') {
+                depth++;
+            }
+            else if (char === '}' || char === ']') {
+                depth--;
+            }
+            else if (char === ',' && depth === 0) {
+                pairs.push(current.trim());
+                current = '';
+                continue;
+            }
+            current += char;
+        }
+        if (current.trim()) {
+            pairs.push(current.trim());
+        }
+        // Parse each key:value pair
+        for (const pair of pairs) {
+            const colonIndex = pair.indexOf(':');
+            if (colonIndex === -1)
+                continue;
+            const key = pair.substring(0, colonIndex).trim();
+            const value = pair.substring(colonIndex + 1).trim();
+            config[key] = this.parseValue(value);
+        }
+        return config;
+    }
+    /**
+     * Parse individual values
+     */
+    parseValue(str) {
+        str = str.trim();
+        // Boolean
+        if (str === 'true')
+            return true;
+        if (str === 'false')
+            return false;
+        // Number
+        if (/^-?\d+(\.\d+)?$/.test(str))
+            return parseFloat(str);
+        // String
+        if ((str.startsWith('"') && str.endsWith('"')) || (str.startsWith("'") && str.endsWith("'"))) {
+            return str.slice(1, -1);
+        }
+        // Color object: { r: 0.8, g: 0.2, b: 0.2 }
+        if (str.startsWith('{') && str.endsWith('}')) {
+            return this.parseObjectLiteral(str.slice(1, -1));
+        }
+        // Array: [1, 2, 3]
+        if (str.startsWith('[') && str.endsWith(']')) {
+            const items = str.slice(1, -1).split(',');
+            return items.map((item) => this.parseValue(item));
+        }
+        return str;
+    }
+    /**
+     * Build GraphicsConfiguration from trait annotations
+     */
+    buildGraphicsConfig(traits) {
+        const config = {};
+        for (const trait of traits) {
+            switch (trait.type) {
+                case 'material':
+                    config.material = trait.config;
+                    break;
+                case 'lighting':
+                    config.lighting = trait.config;
+                    break;
+                case 'rendering':
+                    config.rendering = trait.config;
+                    break;
+            }
+        }
+        return config;
+    }
+    /**
+     * Validate trait annotation configuration
+     */
+    validateTraitAnnotation(trait) {
+        const errors = [];
+        switch (trait.type) {
+            case 'material':
+                errors.push(...this.validateMaterialTrait(trait));
+                break;
+            case 'lighting':
+                errors.push(...this.validateLightingTrait(trait));
+                break;
+            case 'rendering':
+                errors.push(...this.validateRenderingTrait(trait));
+                break;
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Validate material trait configuration
+     */
+    validateMaterialTrait(trait) {
+        const errors = [];
+        const { config } = trait;
+        if (config.pbr) {
+            if (config.pbr.metallic !== undefined && (config.pbr.metallic < 0 || config.pbr.metallic > 1)) {
+                errors.push('material.pbr.metallic must be between 0 and 1');
+            }
+            if (config.pbr.roughness !== undefined && (config.pbr.roughness < 0 || config.pbr.roughness > 1)) {
+                errors.push('material.pbr.roughness must be between 0 and 1');
+            }
+        }
+        if (config.compression && !['none', 'dxt', 'astc', 'basis'].includes(config.compression)) {
+            errors.push(`material.compression must be one of: none, dxt, astc, basis`);
+        }
+        return errors;
+    }
+    /**
+     * Validate lighting trait configuration
+     */
+    validateLightingTrait(trait) {
+        const errors = [];
+        const { config } = trait;
+        if (config.preset && !['studio', 'outdoor', 'interior', 'night', 'sunset'].includes(config.preset)) {
+            errors.push('lighting.preset must be one of: studio, outdoor, interior, night, sunset');
+        }
+        if (config.lights) {
+            config.lights.forEach((light, index) => {
+                if (!['directional', 'point', 'spot', 'area', 'ambient'].includes(light.type)) {
+                    errors.push(`lighting.lights[${index}].type must be a valid light type`);
+                }
+                if (light.intensity !== undefined && light.intensity < 0) {
+                    errors.push(`lighting.lights[${index}].intensity must be >= 0`);
+                }
+            });
+        }
+        return errors;
+    }
+    /**
+     * Validate rendering trait configuration
+     */
+    validateRenderingTrait(trait) {
+        const errors = [];
+        const { config } = trait;
+        if (config.quality && !['low', 'medium', 'high', 'ultra'].includes(config.quality)) {
+            errors.push('rendering.quality must be one of: low, medium, high, ultra');
+        }
+        if (config.platform && !['mobile', 'vr', 'desktop'].includes(config.platform)) {
+            errors.push('rendering.platform must be one of: mobile, vr, desktop');
+        }
+        if (config.compression && !['none', 'dxt', 'astc', 'basis'].includes(config.compression)) {
+            errors.push('rendering.compression must be one of: none, dxt, astc, basis');
+        }
+        if (config.maxTextureResolution && config.maxTextureResolution < 128) {
+            errors.push('rendering.maxTextureResolution must be >= 128');
+        }
+        if (config.targetFPS && (config.targetFPS < 24 || config.targetFPS > 240)) {
+            errors.push('rendering.targetFPS must be between 24 and 240');
+        }
+        return errors;
+    }
+    /**
+     * Get trait annotations as graphics traits
+     */
+    createGraphicsTraits(config) {
+        // This will be called by the runtime to create actual trait instances
+        return {
+            material: config.material ? this.createMaterialTrait(config.material) : null,
+            lighting: config.lighting ? this.createLightingTrait(config.lighting) : null,
+            rendering: config.rendering ? this.createRenderingTrait(config.rendering) : null,
+        };
+    }
+    /**
+     * Create MaterialTrait from config
+     */
+    createMaterialTrait(config) {
+        // Lazy import to avoid circular dependencies
+        const { MaterialTrait } = require('./traits/MaterialTrait');
+        const material = new MaterialTrait({
+            type: config.type || 'pbr',
+            pbr: config.pbr,
+        });
+        if (config.compression) {
+            material.setCompression(config.compression);
+        }
+        if (config.instancing) {
+            material.setInstanced(true);
+        }
+        if (config.streaming) {
+            material.setTextureStreaming(true);
+        }
+        if (config.textures) {
+            config.textures.forEach((tex) => {
+                material.addTexture(tex);
+            });
+        }
+        return material;
+    }
+    /**
+     * Create LightingTrait from config
+     */
+    createLightingTrait(config) {
+        const { LightingTrait, LIGHTING_PRESETS } = require('./traits/LightingTrait');
+        let lighting;
+        if (config.preset) {
+            const preset = LIGHTING_PRESETS[config.preset];
+            lighting = new LightingTrait(preset);
+        }
+        else {
+            lighting = new LightingTrait();
+        }
+        if (config.globalIllumination) {
+            lighting.setGlobalIllumination(config.globalIllumination);
+        }
+        if (config.lights) {
+            config.lights.forEach((light) => {
+                lighting.addLight(light);
+            });
+        }
+        return lighting;
+    }
+    /**
+     * Create RenderingTrait from config
+     */
+    createRenderingTrait(config) {
+        const { RenderingTrait } = require('./traits/RenderingTrait');
+        const rendering = new RenderingTrait();
+        if (config.quality) {
+            rendering.applyQualityPreset(config.quality);
+        }
+        if (config.platform) {
+            switch (config.platform) {
+                case 'mobile':
+                    rendering.optimizeForMobile();
+                    break;
+                case 'vr':
+                    rendering.optimizeForVRAR(config.targetFPS || 90);
+                    break;
+                case 'desktop':
+                    rendering.optimizeForDesktop();
+                    break;
+            }
+        }
+        if (config.lod !== false) {
+            rendering.setupLODLevels('automatic');
+        }
+        if (config.culling !== false) {
+            rendering.setFrustumCulling(true);
+        }
+        if (config.compression) {
+            rendering.setTextureCompression(config.compression);
+        }
+        if (config.maxTextureResolution) {
+            rendering.setMaxTextureResolution(config.maxTextureResolution);
+        }
+        return rendering;
+    }
+}
+export default HoloScriptPlusParser;