@holoscript/core 1.0.0-alpha.1 → 2.0.0

package/src/HoloScriptRuntime.test.js

@@ -0,0 +1,351 @@
+/**
+ * HoloScript Runtime Tests
+ *
+ * Comprehensive test suite for the HoloScript runtime engine.
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { HoloScriptRuntime } from './HoloScriptRuntime';
+import { HoloScriptCodeParser } from './HoloScriptCodeParser';
+describe('HoloScriptRuntime', () => {
+    let runtime;
+    let parser;
+    beforeEach(() => {
+        runtime = new HoloScriptRuntime();
+        parser = new HoloScriptCodeParser();
+    });
+    describe('Basic Execution', () => {
+        it('should create an orb', async () => {
+            const orbNode = {
+                type: 'orb',
+                name: 'testOrb',
+                properties: { message: 'Hello World' },
+                methods: [],
+                position: { x: 1, y: 2, z: 3 },
+                hologram: { shape: 'orb', color: '#00ffff', size: 1, glow: true, interactive: true },
+            };
+            const result = await runtime.executeNode(orbNode);
+            expect(result.success).toBe(true);
+            expect(result.output).toBeDefined();
+            expect(result.spatialPosition).toEqual({ x: 1, y: 2, z: 3 });
+        });
+        it('should define a function', async () => {
+            const funcNode = {
+                type: 'method',
+                name: 'testFunc',
+                parameters: [{ type: 'parameter', name: 'x', dataType: 'number' }],
+                body: [],
+                position: { x: 0, y: 0, z: 0 },
+            };
+            const result = await runtime.executeNode(funcNode);
+            expect(result.success).toBe(true);
+            expect(result.output).toContain('testFunc');
+        });
+        it('should create a connection', async () => {
+            // First create two orbs
+            const orb1 = { type: 'orb', name: 'source', properties: {}, methods: [], position: { x: 0, y: 0, z: 0 } };
+            const orb2 = { type: 'orb', name: 'target', properties: {}, methods: [], position: { x: 5, y: 0, z: 0 } };
+            await runtime.executeNode(orb1);
+            await runtime.executeNode(orb2);
+            const connNode = {
+                type: 'connection',
+                from: 'source',
+                to: 'target',
+                dataType: 'number',
+                bidirectional: false,
+            };
+            const result = await runtime.executeNode(connNode);
+            expect(result.success).toBe(true);
+            expect(result.output).toContain('source');
+            expect(result.output).toContain('target');
+        });
+    });
+    describe('Expression Evaluation', () => {
+        it('should evaluate number literals', () => {
+            expect(runtime.evaluateExpression('42')).toBe(42);
+            expect(runtime.evaluateExpression('-3.14')).toBe(-3.14);
+            expect(runtime.evaluateExpression('0')).toBe(0);
+        });
+        it('should evaluate string literals', () => {
+            expect(runtime.evaluateExpression('"hello"')).toBe('hello');
+            expect(runtime.evaluateExpression("'world'")).toBe('world');
+        });
+        it('should evaluate boolean literals', () => {
+            expect(runtime.evaluateExpression('true')).toBe(true);
+            expect(runtime.evaluateExpression('false')).toBe(false);
+        });
+        it('should evaluate array literals', () => {
+            expect(runtime.evaluateExpression('[]')).toEqual([]);
+            expect(runtime.evaluateExpression('[1, 2, 3]')).toEqual([1, 2, 3]);
+            expect(runtime.evaluateExpression('["a", "b"]')).toEqual(['a', 'b']);
+        });
+        it('should evaluate object literals', () => {
+            expect(runtime.evaluateExpression('{}')).toEqual({});
+            expect(runtime.evaluateExpression('{x: 1, y: 2}')).toEqual({ x: 1, y: 2 });
+        });
+        it('should evaluate arithmetic operations', () => {
+            runtime.setVariable('a', 10);
+            runtime.setVariable('b', 3);
+            expect(runtime.evaluateExpression('a + b')).toBe(13);
+            expect(runtime.evaluateExpression('a - b')).toBe(7);
+            expect(runtime.evaluateExpression('a * b')).toBe(30);
+            expect(runtime.evaluateExpression('a / b')).toBeCloseTo(3.33, 1);
+        });
+    });
+    describe('Built-in Functions', () => {
+        it('should execute math functions', async () => {
+            const result1 = await runtime.callFunction('add', [5, 3]);
+            expect(result1.success).toBe(true);
+            expect(result1.output).toBe(8);
+            const result2 = await runtime.callFunction('multiply', [4, 7]);
+            expect(result2.success).toBe(true);
+            expect(result2.output).toBe(28);
+            const result3 = await runtime.callFunction('abs', [-42]);
+            expect(result3.success).toBe(true);
+            expect(result3.output).toBe(42);
+        });
+        it('should execute string functions', async () => {
+            const result1 = await runtime.callFunction('concat', ['Hello', ' ', 'World']);
+            expect(result1.success).toBe(true);
+            expect(result1.output).toBe('Hello World');
+            const result2 = await runtime.callFunction('uppercase', ['test']);
+            expect(result2.success).toBe(true);
+            expect(result2.output).toBe('TEST');
+            const result3 = await runtime.callFunction('length', ['hello']);
+            expect(result3.success).toBe(true);
+            expect(result3.output).toBe(5);
+        });
+        it('should execute array functions', async () => {
+            const arr = [1, 2, 3];
+            const result1 = await runtime.callFunction('push', [arr, 4]);
+            expect(result1.success).toBe(true);
+            expect(result1.output).toEqual([1, 2, 3, 4]);
+            const result2 = await runtime.callFunction('length', [[1, 2, 3, 4, 5]]);
+            expect(result2.success).toBe(true);
+            expect(result2.output).toBe(5);
+        });
+        it('should execute type checking functions', async () => {
+            expect((await runtime.callFunction('isNumber', [42])).output).toBe(true);
+            expect((await runtime.callFunction('isNumber', ['hello'])).output).toBe(false);
+            expect((await runtime.callFunction('isString', ['hello'])).output).toBe(true);
+            expect((await runtime.callFunction('isArray', [[1, 2, 3]])).output).toBe(true);
+        });
+    });
+    describe('Variable Scoping', () => {
+        it('should set and get variables', () => {
+            runtime.setVariable('x', 100);
+            expect(runtime.getVariable('x')).toBe(100);
+            runtime.setVariable('y', 'hello');
+            expect(runtime.getVariable('y')).toBe('hello');
+        });
+        it('should handle nested property access', () => {
+            runtime.setVariable('obj', { nested: { value: 42 } });
+            expect(runtime.getVariable('obj.nested.value')).toBe(42);
+        });
+        it('should set nested properties', () => {
+            runtime.setVariable('data.x', 10);
+            runtime.setVariable('data.y', 20);
+            expect(runtime.getVariable('data')).toEqual({ x: 10, y: 20 });
+        });
+    });
+    describe('Gate Execution', () => {
+        it('should execute true path when condition is true', async () => {
+            runtime.setVariable('value', 10);
+            const gateNode = {
+                type: 'gate',
+                condition: 'value > 5',
+                truePath: [],
+                falsePath: [],
+                position: { x: 0, y: 0, z: 0 },
+            };
+            const result = await runtime.executeNode(gateNode);
+            expect(result.success).toBe(true);
+            expect(result.output).toContain('true');
+        });
+        it('should execute false path when condition is false', async () => {
+            runtime.setVariable('value', 3);
+            const gateNode = {
+                type: 'gate',
+                condition: 'value > 5',
+                truePath: [],
+                falsePath: [],
+                position: { x: 0, y: 0, z: 0 },
+            };
+            const result = await runtime.executeNode(gateNode);
+            expect(result.success).toBe(true);
+            expect(result.output).toContain('false');
+        });
+        it('should handle boolean literals in conditions', async () => {
+            const trueGate = {
+                type: 'gate',
+                condition: 'true',
+                truePath: [],
+                falsePath: [],
+            };
+            const falseGate = {
+                type: 'gate',
+                condition: 'false',
+                truePath: [],
+                falsePath: [],
+            };
+            const result1 = await runtime.executeNode(trueGate);
+            expect(result1.output).toContain('true');
+            const result2 = await runtime.executeNode(falseGate);
+            expect(result2.output).toContain('false');
+        });
+        it('should handle comparison operators', async () => {
+            runtime.setVariable('a', 5);
+            runtime.setVariable('b', 5);
+            const tests = [
+                { condition: 'a == b', expected: true },
+                { condition: 'a != b', expected: false },
+                { condition: 'a >= b', expected: true },
+                { condition: 'a <= b', expected: true },
+                { condition: 'a > b', expected: false },
+                { condition: 'a < b', expected: false },
+            ];
+            for (const { condition, expected } of tests) {
+                const gate = { type: 'gate', condition, truePath: [], falsePath: [] };
+                const result = await runtime.executeNode(gate);
+                expect(result.output).toContain(expected ? 'true' : 'false');
+            }
+        });
+    });
+    describe('Stream Execution', () => {
+        it('should process stream with transformations', async () => {
+            runtime.setVariable('numbers', [1, 2, 3, 4, 5]);
+            const streamNode = {
+                type: 'stream',
+                name: 'testStream',
+                source: 'numbers',
+                transformations: [
+                    { type: 'transformation', operation: 'sum', parameters: {} },
+                ],
+                position: { x: 0, y: 0, z: 0 },
+            };
+            const result = await runtime.executeNode(streamNode);
+            expect(result.success).toBe(true);
+            expect(runtime.getVariable('testStream_result')).toBe(15);
+        });
+        it('should handle multiple transformations', async () => {
+            runtime.setVariable('data', [5, 3, 8, 1, 9]);
+            const streamNode = {
+                type: 'stream',
+                name: 'multiStream',
+                source: 'data',
+                transformations: [
+                    { type: 'transformation', operation: 'sort', parameters: {} },
+                    { type: 'transformation', operation: 'take', parameters: { count: 3 } },
+                ],
+                position: { x: 0, y: 0, z: 0 },
+            };
+            const result = await runtime.executeNode(streamNode);
+            expect(result.success).toBe(true);
+            expect(runtime.getVariable('multiStream_result')).toEqual([1, 3, 5]);
+        });
+    });
+    describe('Event System', () => {
+        it('should register and emit events', async () => {
+            let eventFired = false;
+            let eventData = null;
+            runtime.on('test.event', (data) => {
+                eventFired = true;
+                eventData = data;
+            });
+            await runtime.emit('test.event', { value: 42 });
+            expect(eventFired).toBe(true);
+            expect(eventData).toEqual({ value: 42 });
+        });
+        it('should remove event handlers', async () => {
+            let count = 0;
+            const handler = () => { count++; };
+            runtime.on('counter', handler);
+            await runtime.emit('counter');
+            expect(count).toBe(1);
+            runtime.off('counter', handler);
+            await runtime.emit('counter');
+            expect(count).toBe(1); // Should not increment
+        });
+    });
+    describe('Code Parser Integration', () => {
+        it('should parse and execute orb declaration', async () => {
+            const code = `
+        orb greeting {
+          message: "Hello"
+          color: "#ff0000"
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            expect(parseResult.ast.length).toBe(1);
+            const results = await runtime.executeProgram(parseResult.ast);
+            expect(results[0].success).toBe(true);
+        });
+        it('should parse and execute function declaration', async () => {
+            const code = `
+        function greet(name: string): string {
+          return name
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            const results = await runtime.executeProgram(parseResult.ast);
+            expect(results[0].success).toBe(true);
+            const context = runtime.getContext();
+            expect(context.functions.has('greet')).toBe(true);
+        });
+        it('should parse and execute connection', async () => {
+            const code = `
+        orb source { value: 10 }
+        orb target { value: 0 }
+        connect source to target as "number"
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            expect(parseResult.ast.length).toBe(3);
+            const results = await runtime.executeProgram(parseResult.ast);
+            expect(results.every(r => r.success)).toBe(true);
+            const context = runtime.getContext();
+            expect(context.connections.length).toBe(1);
+        });
+    });
+    describe('Security', () => {
+        it('should block suspicious keywords in expressions', () => {
+            expect(runtime.evaluateExpression('eval("1+1")')).toBeUndefined();
+            expect(runtime.evaluateExpression('process.exit()')).toBeUndefined();
+            expect(runtime.evaluateExpression('require("fs")')).toBeUndefined();
+        });
+        it('should respect execution limits', async () => {
+            // Create a very deep recursion scenario
+            const nodes = Array(2000).fill(null).map((_, i) => ({
+                type: 'orb',
+                name: `orb${i}`,
+                properties: {},
+                methods: [],
+            }));
+            const results = await runtime.executeProgram(nodes);
+            // Should have stopped before completing all
+            const lastResult = results[results.length - 1];
+            expect(lastResult.error).toContain('Max total nodes exceeded');
+        });
+    });
+    describe('Reset', () => {
+        it('should clear all state on reset', async () => {
+            // Set up some state
+            runtime.setVariable('x', 100);
+            await runtime.executeNode({
+                type: 'orb',
+                name: 'testOrb',
+                properties: {},
+                methods: [],
+            });
+            runtime.on('test', () => { });
+            // Reset
+            runtime.reset();
+            // Verify state is cleared
+            expect(runtime.getVariable('x')).toBeUndefined();
+            expect(runtime.getContext().variables.size).toBe(0);
+            expect(runtime.getContext().functions.size).toBe(0);
+            expect(runtime.getExecutionHistory()).toHaveLength(0);
+        });
+    });
+});

package/src/HoloScriptRuntime.ts

@@ -24,12 +24,14 @@ import type {
   StreamNode,
   SpatialPosition,
   HologramProperties,
+  HologramShape,
   RuntimeContext,
   ExecutionResult,
   ParticleSystem,
   TransformationNode,
   UI2DNode,
 } from './types';
+import type { ImportLoader } from './types';
 
 const RUNTIME_SECURITY_LIMITS = {
   maxExecutionDepth: 50,
@@ -95,7 +97,7 @@ export class HoloScriptRuntime {
   private uiElements: Map<string, UIElementState> = new Map();
   private builtinFunctions: Map<string, (args: unknown[]) => unknown>;
 
-  constructor() {
+  constructor(_importLoader?: ImportLoader) {
     this.context = this.createEmptyContext();
     this.currentScope = { variables: this.context.variables };
     this.builtinFunctions = this.initBuiltins();
@@ -316,6 +318,12 @@ export class HoloScriptRuntime {
         case 'return':
           result = await this.executeReturn(node as ASTNode & { value: unknown });
           break;
+        case 'generic':
+          result = await this.executeGeneric(node);
+          break;
+        case 'expression-statement':
+          result = await this.executeCall(node);
+          break;
         default:
           result = {
             success: false,
@@ -539,7 +547,16 @@ export class HoloScriptRuntime {
     }
 
     // Check context variables
-    return this.context.variables.get(name);
+    if (this.context.variables.has(name)) {
+      return this.context.variables.get(name);
+    }
+
+    // Fallback to functions map (for imported functions)
+    if (this.context.functions.has(name)) {
+      return this.context.functions.get(name);
+    }
+
+    return undefined;
   }
 
   /**
@@ -621,7 +638,7 @@ export class HoloScriptRuntime {
 
     // Binary operations: a + b, a - b, etc.
     const binaryOps = [
-      { pattern: /(.+)\s*\+\s*(.+)/, op: (a: unknown, b: unknown) => Number(a) + Number(b) },
+      { pattern: /(.+)\s*\+\s*(.+)/, op: (a: unknown, b: unknown) => (typeof a === 'string' || typeof b === 'string') ? String(a) + String(b) : Number(a) + Number(b) },
       { pattern: /(.+)\s*-\s*(.+)/, op: (a: unknown, b: unknown) => Number(a) - Number(b) },
       { pattern: /(.+)\s*\*\s*(.+)/, op: (a: unknown, b: unknown) => Number(a) * Number(b) },
       { pattern: /(.+)\s*\/\s*(.+)/, op: (a: unknown, b: unknown) => Number(b) !== 0 ? Number(a) / Number(b) : 0 },
@@ -939,6 +956,242 @@ export class HoloScriptRuntime {
     };
   }
 
+  /**
+   * Execute generic voice commands
+   * Handles commands like: show, hide, animate, pulse, create
+   */
+  private async executeGeneric(_node: ASTNode): Promise<ExecutionResult> {
+    const genericNode = _node as any;
+    const command = String(genericNode.command || '').trim().toLowerCase();
+    const tokens = command.split(/\s+/);
+    const action = tokens[0];
+    const target = tokens[1];
+
+    logger.info('Executing generic command', { command, action, target });
+
+    try {
+      let result: any;
+
+      switch (action) {
+        case 'show':
+          result = await this.executeShowCommand(target, genericNode);
+          break;
+        case 'hide':
+          result = await this.executeHideCommand(target, genericNode);
+          break;
+        case 'create':
+        case 'summon':
+          result = await this.executeCreateCommand(tokens.slice(1), genericNode);
+          break;
+        case 'animate':
+          result = await this.executeAnimateCommand(target, tokens.slice(2), genericNode);
+          break;
+        case 'pulse':
+          result = await this.executePulseCommand(target, tokens.slice(2), genericNode);
+          break;
+        case 'move':
+          result = await this.executeMoveCommand(target, tokens.slice(2), genericNode);
+          break;
+        case 'delete':
+        case 'remove':
+          result = await this.executeDeleteCommand(target, genericNode);
+          break;
+        default:
+          // Default: create visual representation of the generic command
+          logger.warn('Unknown voice command action', { action, command });
+          result = {
+            executed: false,
+            message: `Unknown command: ${action}`,
+          };
+      }
+
+      return {
+        success: true,
+        output: result,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: `Generic command execution failed: ${String(error)}`,
+      };
+    }
+  }
+
+  /**
+   * Execute 'show' command
+   */
+  private async executeShowCommand(target: string, _node: any): Promise<any> {
+    // Create or show orb for this target
+    const hologram = _node.hologram || {
+      shape: 'orb',
+      color: '#00ffff',
+      size: 0.8,
+      glow: true,
+      interactive: true,
+    };
+
+    const position = _node.position || { x: 0, y: 0, z: 0 };
+    this.context.spatialMemory.set(target, position);
+    this.createParticleEffect(`${target}_show`, position, hologram.color, 15);
+
+    logger.info('Show command executed', { target, position });
+
+    return {
+      showed: target,
+      hologram,
+      position,
+    };
+  }
+
+  /**
+   * Execute 'hide' command
+   */
+  private async executeHideCommand(target: string, _node: any): Promise<any> {
+    const position = this.context.spatialMemory.get(target) || { x: 0, y: 0, z: 0 };
+    this.createParticleEffect(`${target}_hide`, position, '#ff0000', 10);
+    
+    logger.info('Hide command executed', { target });
+
+    return {
+      hidden: target,
+    };
+  }
+
+  /**
+   * Execute 'create' command
+   */
+  private async executeCreateCommand(tokens: string[], _node: any): Promise<any> {
+    if (tokens.length < 2) {
+      return { error: 'Create command requires shape and name' };
+    }
+
+    const shape = tokens[0];
+    const name = tokens[1];
+    const position = _node.position || { x: 0, y: 0, z: 0 };
+
+    const hologram: HologramProperties = {
+      shape: shape as HologramShape,
+      color: _node.hologram?.color || '#00ffff',
+      size: _node.hologram?.size || 1,
+      glow: _node.hologram?.glow !== false,
+      interactive: _node.hologram?.interactive !== false,
+    };
+
+    this.context.spatialMemory.set(name, position);
+    this.createParticleEffect(`${name}_create`, position, hologram.color, 20);
+
+    logger.info('Create command executed', { shape, name, position });
+
+    return {
+      created: name,
+      shape,
+      hologram,
+      position,
+    };
+  }
+
+  /**
+   * Execute 'animate' command
+   */
+  private async executeAnimateCommand(target: string, tokens: string[], _node: any): Promise<any> {
+    const property = tokens[0] || 'position.y';
+    const duration = parseInt(tokens[1] || '1000', 10);
+    
+    const animation: Animation = {
+      target,
+      property,
+      from: 0,
+      to: 1,
+      duration,
+      startTime: Date.now(),
+      easing: 'ease-in-out',
+    };
+
+    this.animations.set(`${target}_${property}`, animation);
+
+    logger.info('Animate command executed', { target, property, duration });
+
+    return {
+      animating: target,
+      animation,
+    };
+  }
+
+  /**
+   * Execute 'pulse' command
+   */
+  private async executePulseCommand(target: string, tokens: string[], _node: any): Promise<any> {
+    const duration = parseInt(tokens[0] || '500', 10);
+    const position = this.context.spatialMemory.get(target) || { x: 0, y: 0, z: 0 };
+
+    // Create pulsing particle effect
+    this.createParticleEffect(`${target}_pulse`, position, '#ffff00', 30);
+
+    // Create animation for scale
+    const animation: Animation = {
+      target,
+      property: 'scale',
+      from: 1,
+      to: 1.5,
+      duration,
+      startTime: Date.now(),
+      easing: 'sine',
+      yoyo: true,
+      loop: true,
+    };
+
+    this.animations.set(`${target}_pulse`, animation);
+
+    logger.info('Pulse command executed', { target, duration });
+
+    return {
+      pulsing: target,
+      duration,
+    };
+  }
+
+  /**
+   * Execute 'move' command
+   */
+  private async executeMoveCommand(target: string, tokens: string[], _node: any): Promise<any> {
+    const x = parseFloat(tokens[0] || '0');
+    const y = parseFloat(tokens[1] || '0');
+    const z = parseFloat(tokens[2] || '0');
+    const position: SpatialPosition = { x, y, z };
+
+    const current = this.context.spatialMemory.get(target);
+    if (current) {
+      this.context.spatialMemory.set(target, position);
+      this.createConnectionStream(target, `${target}_move`, current, position, 'movement');
+    } else {
+      this.context.spatialMemory.set(target, position);
+    }
+
+    logger.info('Move command executed', { target, position });
+
+    return {
+      moved: target,
+      to: position,
+    };
+  }
+
+  /**
+   * Execute 'delete' command
+   */
+  private async executeDeleteCommand(target: string, _node: any): Promise<any> {
+    const position = this.context.spatialMemory.get(target);
+    if (position) {
+      this.createParticleEffect(`${target}_delete`, position, '#ff0000', 15);
+      this.context.spatialMemory.delete(target);
+    }
+
+    logger.info('Delete command executed', { target });
+
+    return {
+      deleted: target,
+    };
+  }
+
   private async executeStructure(node: ASTNode): Promise<ExecutionResult> {
     // Handle nexus, building, and other structural elements
     const hologram: HologramProperties = node.hologram || {
@@ -1378,6 +1631,7 @@ export class HoloScriptRuntime {
     return {
       variables: new Map(),
       functions: new Map(),
+      exports: new Map(),
       connections: [],
       spatialMemory: new Map(),
       hologramState: new Map(),