@holoscript/core 1.0.0-alpha.2 → 2.0.0

package/src/__tests__/integration.test.js

@@ -0,0 +1,336 @@
+/**
+ * HoloScript Integration Tests
+ *
+ * End-to-end tests that verify the complete pipeline:
+ * Parser -> Runtime -> Type Checker -> Debugger
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { HoloScriptCodeParser } from '../HoloScriptCodeParser';
+import { HoloScriptRuntime } from '../HoloScriptRuntime';
+import { HoloScriptTypeChecker } from '../HoloScriptTypeChecker';
+import { HoloScriptDebugger } from '../HoloScriptDebugger';
+describe('HoloScript Integration Tests', () => {
+    let parser;
+    let runtime;
+    let typeChecker;
+    beforeEach(() => {
+        parser = new HoloScriptCodeParser();
+        runtime = new HoloScriptRuntime();
+        typeChecker = new HoloScriptTypeChecker();
+    });
+    describe('Parser -> Runtime Pipeline', () => {
+        it('should parse and execute a simple orb declaration', async () => {
+            const code = `
+        orb myOrb {
+          name: "TestOrb"
+          color: "#ff0000"
+          glow: true
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            expect(parseResult.ast.length).toBeGreaterThan(0);
+            const results = await runtime.executeProgram(parseResult.ast);
+            expect(results.length).toBeGreaterThan(0);
+            expect(results[0].success).toBe(true);
+        });
+        it('should parse and execute a function definition', async () => {
+            const code = `
+        function greet(name: string): string {
+          return "Hello, " + name
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            const results = await runtime.executeProgram(parseResult.ast);
+            expect(results[0].success).toBe(true);
+            // Call the function
+            const callResult = await runtime.callFunction('greet', ['World']);
+            expect(callResult.success).toBe(true);
+        });
+        it('should parse and execute connections between orbs', async () => {
+            const code = `
+        orb source {
+          name: "Source"
+        }
+        orb target {
+          name: "Target"
+        }
+        connect source to target as "data"
+      `;
+            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);
+        });
+        it('should handle program with multiple orbs', async () => {
+            const code = `
+        orb dataOrb {
+          value: 42
+          name: "DataOrb"
+        }
+
+        orb outputOrb {
+          name: "OutputOrb"
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            expect(parseResult.ast.length).toBeGreaterThanOrEqual(2);
+            const results = await runtime.executeProgram(parseResult.ast);
+            expect(results.length).toBeGreaterThanOrEqual(2);
+        });
+    });
+    describe('Parser -> Type Checker Pipeline', () => {
+        it('should type check orb declarations', () => {
+            const code = `
+        orb typedOrb {
+          count: 10
+          name: "TypedOrb"
+          active: true
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            const typeResult = typeChecker.check(parseResult.ast);
+            expect(typeResult.valid).toBe(true);
+            expect(typeResult.diagnostics.length).toBe(0);
+        });
+        it('should type check function signatures', () => {
+            const code = `
+        function add(a: number, b: number): number {
+          return a + b
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            const typeResult = typeChecker.check(parseResult.ast);
+            expect(typeResult.valid).toBe(true);
+        });
+        it('should detect type information', () => {
+            const code = `
+        const MAX_VALUE = 100
+        let counter = 0
+
+        orb configOrb {
+          limit: MAX_VALUE
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            const typeResult = typeChecker.check(parseResult.ast);
+            expect(typeResult.typeMap.size).toBeGreaterThan(0);
+        });
+    });
+    describe('Full Pipeline: Parse -> Type Check -> Execute', () => {
+        it('should process a complete program through all stages', async () => {
+            const code = `
+        orb sensorOrb {
+          reading: 75
+          name: "Sensor"
+        }
+
+        function checkReading(value: number): boolean {
+          return value > 50
+        }
+      `;
+            // Stage 1: Parse
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            expect(parseResult.errors.length).toBe(0);
+            // Stage 2: Type Check
+            const typeResult = typeChecker.check(parseResult.ast);
+            expect(typeResult.valid).toBe(true);
+            // Stage 3: Execute
+            const execResults = await runtime.executeProgram(parseResult.ast);
+            expect(execResults.every(r => r.success)).toBe(true);
+        });
+    });
+    describe('Debugger Integration', () => {
+        it('should load source and set breakpoints', () => {
+            const debugger_ = new HoloScriptDebugger(runtime);
+            const code = `
+        orb debugOrb {
+          name: "DebugOrb"
+        }
+
+        function test() {
+          show debugOrb
+        }
+      `;
+            const loadResult = debugger_.loadSource(code);
+            expect(loadResult.success).toBe(true);
+            const bp = debugger_.setBreakpoint(2);
+            expect(bp.id).toBeDefined();
+            expect(bp.line).toBe(2);
+            expect(bp.enabled).toBe(true);
+            const breakpoints = debugger_.getBreakpoints();
+            expect(breakpoints.length).toBe(1);
+        });
+        it('should step through execution', async () => {
+            const debugger_ = new HoloScriptDebugger(runtime);
+            const code = `
+        orb stepOrb {
+          name: "StepOrb"
+        }
+      `;
+            debugger_.loadSource(code);
+            // Start and immediately pause
+            await debugger_.start();
+            const state = debugger_.getState();
+            expect(state.status).toBeDefined();
+        });
+        it('should evaluate expressions in debug context', async () => {
+            const debugger_ = new HoloScriptDebugger(runtime);
+            const code = `
+        orb evalOrb {
+          value: 42
+        }
+      `;
+            debugger_.loadSource(code);
+            await debugger_.start();
+            // Wait for execution to complete
+            const result = await debugger_.evaluate('evalOrb');
+            expect(result).toBeDefined();
+        });
+        it('should handle breakpoint events', async () => {
+            const debugger_ = new HoloScriptDebugger(runtime);
+            const events = [];
+            debugger_.on('breakpoint-hit', () => events.push('breakpoint'));
+            debugger_.on('state-change', () => events.push('state'));
+            const code = `
+        orb eventOrb {
+          name: "EventOrb"
+        }
+      `;
+            debugger_.loadSource(code);
+            debugger_.setBreakpoint(2);
+            await debugger_.start();
+            // Events should have been captured
+            expect(events.length).toBeGreaterThanOrEqual(0);
+        });
+    });
+    describe('Error Handling', () => {
+        it('should handle parse errors gracefully', () => {
+            const code = `
+        orb { invalid syntax here
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(false);
+            expect(parseResult.errors.length).toBeGreaterThan(0);
+        });
+        it('should handle runtime errors gracefully', async () => {
+            const code = `
+        function errorFunc() {
+          throw "Error"
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            const results = await runtime.executeProgram(parseResult.ast);
+            // Function definition should succeed
+            expect(results[0].success).toBe(true);
+        });
+        it('should handle debugger errors gracefully', async () => {
+            const debugger_ = new HoloScriptDebugger(runtime);
+            // Completely invalid syntax that parser will reject
+            const loadResult = debugger_.loadSource('{{{{{{');
+            // Parser may or may not reject this depending on implementation
+            // Just verify we get a result without crashing
+            expect(loadResult).toBeDefined();
+        });
+    });
+    describe('Loop Constructs', () => {
+        it('should parse for loops', () => {
+            const code = `
+        for (i = 0; i < 10; i++) {
+          show i
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            expect(parseResult.ast[0].type).toBe('for-loop');
+        });
+        it.todo('should parse while loops - needs parser enhancement');
+        it.todo('should parse forEach loops - needs parser enhancement');
+    });
+    describe('Module System', () => {
+        it.todo('should parse import statements - needs parser enhancement');
+        it('should parse export statements', () => {
+            const code = `
+        export function helper() {
+          return 42
+        }
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            expect(parseResult.ast[0].type).toBe('export');
+        });
+        it('should parse variable declarations', () => {
+            const code = `
+        const MAX = 100
+        let count = 0
+        var legacy = true
+      `;
+            const parseResult = parser.parse(code);
+            expect(parseResult.success).toBe(true);
+            expect(parseResult.ast.length).toBe(3);
+            expect(parseResult.ast[0].type).toBe('variable-declaration');
+        });
+    });
+    describe('Runtime Context', () => {
+        it('should maintain variable state across executions', async () => {
+            const code1 = `
+        orb stateOrb {
+          counter: 0
+        }
+      `;
+            const parseResult1 = parser.parse(code1);
+            await runtime.executeProgram(parseResult1.ast);
+            // Context should exist after execution
+            const context = runtime.getContext();
+            expect(context).toBeDefined();
+            expect(context.variables).toBeDefined();
+        });
+        it('should support function calls with arguments', async () => {
+            const code = `
+        function multiply(a: number, b: number): number {
+          return a * b
+        }
+      `;
+            const parseResult = parser.parse(code);
+            await runtime.executeProgram(parseResult.ast);
+            const result = await runtime.callFunction('multiply', [5, 3]);
+            expect(result.success).toBe(true);
+        });
+        it('should reset context on runtime reset', async () => {
+            const code = `
+        orb tempOrb {
+          name: "Temporary"
+        }
+      `;
+            const parseResult = parser.parse(code);
+            await runtime.executeProgram(parseResult.ast);
+            const contextBefore = runtime.getContext();
+            expect(contextBefore).toBeDefined();
+            runtime.reset();
+            const contextAfter = runtime.getContext();
+            // After reset, variables should be empty
+            expect(contextAfter.variables.size).toBe(0);
+        });
+    });
+});
+describe('HoloScript Bridge Integration', () => {
+    // These tests would require the Hololand bridge
+    // Stubbed for now - would need mock world interface
+    it.skip('should sync orbs to world objects', async () => {
+        // Would test HoloScriptBridge.loadScript -> world.createObject
+    });
+    it.skip('should handle world events', async () => {
+        // Would test world.emit -> bridge event handling
+    });
+    it.skip('should sync runtime state to world', async () => {
+        // Would test bridge.sync() updating world objects
+    });
+});

package/src/__tests__/performance.bench.js

@@ -0,0 +1,218 @@
+/**
+ * HoloScript Performance Benchmarks
+ *
+ * Measures parsing, execution, and type checking performance.
+ * Run with: npx vitest bench
+ */
+import { describe, bench, beforeAll } from 'vitest';
+import { HoloScriptCodeParser } from '../HoloScriptCodeParser';
+import { HoloScriptRuntime } from '../HoloScriptRuntime';
+import { HoloScriptTypeChecker } from '../HoloScriptTypeChecker';
+// Test data
+const SIMPLE_ORB = `
+orb testOrb {
+  name: "TestOrb"
+  color: "#ff0000"
+  glow: true
+}
+`;
+const MULTIPLE_ORBS = Array.from({ length: 10 }, (_, i) => `
+orb orb${i} {
+  name: "Orb${i}"
+  color: "#${i.toString(16).padStart(6, '0')}"
+  value: ${i * 10}
+}
+`).join('\n');
+const COMPLEX_PROGRAM = `
+orb dataSource {
+  name: "DataSource"
+  rate: 100
+}
+
+orb processor {
+  name: "Processor"
+  capacity: 1000
+}
+
+orb output {
+  name: "Output"
+  format: "json"
+}
+
+function processData(input: number): number {
+  return input * 2
+}
+
+function validateInput(data: object): boolean {
+  return true
+}
+
+connect dataSource to processor as "raw"
+connect processor to output as "processed"
+`;
+const FUNCTIONS_PROGRAM = Array.from({ length: 20 }, (_, i) => `
+function func${i}(x: number): number {
+  return x + ${i}
+}
+`).join('\n');
+describe('Parser Performance', () => {
+    let parser;
+    beforeAll(() => {
+        parser = new HoloScriptCodeParser();
+    });
+    bench('parse simple orb', () => {
+        parser.parse(SIMPLE_ORB);
+    });
+    bench('parse 10 orbs', () => {
+        parser.parse(MULTIPLE_ORBS);
+    });
+    bench('parse complex program', () => {
+        parser.parse(COMPLEX_PROGRAM);
+    });
+    bench('parse 20 functions', () => {
+        parser.parse(FUNCTIONS_PROGRAM);
+    });
+    bench('tokenize simple orb', () => {
+        // @ts-expect-error - accessing private method for benchmark
+        parser.tokenize(SIMPLE_ORB);
+    });
+    bench('tokenize complex program', () => {
+        // @ts-expect-error - accessing private method for benchmark
+        parser.tokenize(COMPLEX_PROGRAM);
+    });
+});
+describe('Runtime Performance', () => {
+    let parser;
+    let runtime;
+    let simpleAST;
+    let complexAST;
+    beforeAll(() => {
+        parser = new HoloScriptCodeParser();
+        runtime = new HoloScriptRuntime();
+        const simpleResult = parser.parse(SIMPLE_ORB);
+        simpleAST = simpleResult.ast;
+        const complexResult = parser.parse(COMPLEX_PROGRAM);
+        complexAST = complexResult.ast;
+    });
+    bench('execute simple orb', async () => {
+        runtime.reset();
+        await runtime.executeProgram(simpleAST);
+    });
+    bench('execute complex program', async () => {
+        runtime.reset();
+        await runtime.executeProgram(complexAST);
+    });
+    bench('execute single node', async () => {
+        if (simpleAST.length > 0) {
+            await runtime.executeNode(simpleAST[0]);
+        }
+    });
+    bench('runtime reset', () => {
+        runtime.reset();
+    });
+    bench('get context', () => {
+        runtime.getContext();
+    });
+    bench('set/get variable', () => {
+        runtime.setVariable('benchVar', 42);
+        runtime.getVariable('benchVar');
+    });
+});
+describe('Type Checker Performance', () => {
+    let parser;
+    let typeChecker;
+    let simpleAST;
+    let complexAST;
+    let functionsAST;
+    beforeAll(() => {
+        parser = new HoloScriptCodeParser();
+        typeChecker = new HoloScriptTypeChecker();
+        const simpleResult = parser.parse(SIMPLE_ORB);
+        simpleAST = simpleResult.ast;
+        const complexResult = parser.parse(COMPLEX_PROGRAM);
+        complexAST = complexResult.ast;
+        const functionsResult = parser.parse(FUNCTIONS_PROGRAM);
+        functionsAST = functionsResult.ast;
+    });
+    bench('type check simple orb', () => {
+        typeChecker.check(simpleAST);
+    });
+    bench('type check complex program', () => {
+        typeChecker.check(complexAST);
+    });
+    bench('type check 20 functions', () => {
+        typeChecker.check(functionsAST);
+    });
+    bench('get all types', () => {
+        typeChecker.check(complexAST);
+        typeChecker.getAllTypes();
+    });
+});
+describe('Full Pipeline Performance', () => {
+    let parser;
+    let runtime;
+    let typeChecker;
+    beforeAll(() => {
+        parser = new HoloScriptCodeParser();
+        runtime = new HoloScriptRuntime();
+        typeChecker = new HoloScriptTypeChecker();
+    });
+    bench('full pipeline: parse -> type check -> execute (simple)', async () => {
+        const parseResult = parser.parse(SIMPLE_ORB);
+        typeChecker.check(parseResult.ast);
+        runtime.reset();
+        await runtime.executeProgram(parseResult.ast);
+    });
+    bench('full pipeline: parse -> type check -> execute (complex)', async () => {
+        const parseResult = parser.parse(COMPLEX_PROGRAM);
+        typeChecker.check(parseResult.ast);
+        runtime.reset();
+        await runtime.executeProgram(parseResult.ast);
+    });
+    bench('parse only (no execution)', () => {
+        parser.parse(COMPLEX_PROGRAM);
+    });
+});
+describe('Memory and Scalability', () => {
+    let parser;
+    let runtime;
+    beforeAll(() => {
+        parser = new HoloScriptCodeParser();
+        runtime = new HoloScriptRuntime();
+    });
+    bench('parse 100 orbs', () => {
+        const largeProgram = Array.from({ length: 100 }, (_, i) => `
+      orb orb${i} {
+        name: "Orb${i}"
+        value: ${i}
+      }
+    `).join('\n');
+        parser.parse(largeProgram);
+    });
+    bench('execute 50 orbs', async () => {
+        const program = Array.from({ length: 50 }, (_, i) => `
+      orb orb${i} {
+        name: "Orb${i}"
+      }
+    `).join('\n');
+        const result = parser.parse(program);
+        runtime.reset();
+        await runtime.executeProgram(result.ast);
+    });
+    bench('many connections', () => {
+        const program = `
+      orb source { name: "Source" }
+      orb a { name: "A" }
+      orb b { name: "B" }
+      orb c { name: "C" }
+      orb d { name: "D" }
+      orb target { name: "Target" }
+      connect source to a as "data"
+      connect a to b as "data"
+      connect b to c as "data"
+      connect c to d as "data"
+      connect d to target as "data"
+    `;
+        parser.parse(program);
+    });
+});

package/src/__tests__/type-checker.test.js

@@ -0,0 +1,60 @@
+/**
+ * HoloScriptTypeChecker Tests - Simplified
+ *
+ * Tests for type checking system
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { HoloScriptTypeChecker } from '../HoloScriptTypeChecker';
+describe('HoloScriptTypeChecker', () => {
+    let typeChecker;
+    beforeEach(() => {
+        typeChecker = new HoloScriptTypeChecker();
+    });
+    describe('Type Inference', () => {
+        it('should initialize type checker', () => {
+            expect(typeChecker).toBeDefined();
+        });
+        it('should infer number type', () => {
+            const result = typeChecker.inferType(42);
+            expect(result.type).toBe('number');
+        });
+        it('should infer string type', () => {
+            const result = typeChecker.inferType('hello');
+            expect(result.type).toBe('string');
+        });
+        it('should infer boolean type', () => {
+            const result = typeChecker.inferType(true);
+            expect(result.type).toBe('boolean');
+        });
+        it('should infer array type', () => {
+            const result = typeChecker.inferType([1, 2, 3]);
+            expect(result.type).toBe('array');
+            expect(result.elementType).toBe('number');
+        });
+        it('should infer object type', () => {
+            const result = typeChecker.inferType({ x: 1 });
+            expect(result.type).toBe('object');
+            expect(result.properties?.size).toBeGreaterThan(0);
+        });
+        it('should infer null/undefined as any with nullable', () => {
+            const result = typeChecker.inferType(null);
+            expect(result.type).toBe('any');
+            expect(result.nullable).toBe(true);
+        });
+    });
+    describe('Type Checking', () => {
+        it('should check AST nodes', () => {
+            const ast = [];
+            const result = typeChecker.check(ast);
+            expect(result.valid).toBeDefined();
+            expect(result.diagnostics).toBeDefined();
+            expect(result.typeMap).toBeDefined();
+        });
+        it('should return valid result for empty AST', () => {
+            const ast = [];
+            const result = typeChecker.check(ast);
+            expect(result.valid).toBe(true);
+            expect(result.diagnostics.length).toBe(0);
+        });
+    });
+});

package/src/__tests__/type-checker.test.ts

@@ -0,0 +1,73 @@
+/**
+ * HoloScriptTypeChecker Tests - Simplified
+ *
+ * Tests for type checking system
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { HoloScriptTypeChecker } from '../HoloScriptTypeChecker';
+
+describe('HoloScriptTypeChecker', () => {
+  let typeChecker: HoloScriptTypeChecker;
+
+  beforeEach(() => {
+    typeChecker = new HoloScriptTypeChecker();
+  });
+
+  describe('Type Inference', () => {
+    it('should initialize type checker', () => {
+      expect(typeChecker).toBeDefined();
+    });
+
+    it('should infer number type', () => {
+      const result = typeChecker.inferType(42);
+      expect(result.type).toBe('number');
+    });
+
+    it('should infer string type', () => {
+      const result = typeChecker.inferType('hello');
+      expect(result.type).toBe('string');
+    });
+
+    it('should infer boolean type', () => {
+      const result = typeChecker.inferType(true);
+      expect(result.type).toBe('boolean');
+    });
+
+    it('should infer array type', () => {
+      const result = typeChecker.inferType([1, 2, 3]);
+      expect(result.type).toBe('array');
+      expect(result.elementType).toBe('number');
+    });
+
+    it('should infer object type', () => {
+      const result = typeChecker.inferType({ x: 1 });
+      expect(result.type).toBe('object');
+      expect(result.properties?.size).toBeGreaterThan(0);
+    });
+
+    it('should infer null/undefined as any with nullable', () => {
+      const result = typeChecker.inferType(null);
+      expect(result.type).toBe('any');
+      expect(result.nullable).toBe(true);
+    });
+  });
+
+  describe('Type Checking', () => {
+    it('should check AST nodes', () => {
+      const ast: any[] = [];
+      const result = typeChecker.check(ast);
+      expect(result.valid).toBeDefined();
+      expect(result.diagnostics).toBeDefined();
+      expect(result.typeMap).toBeDefined();
+    });
+
+    it('should return valid result for empty AST', () => {
+      const ast: any[] = [];
+      const result = typeChecker.check(ast);
+      expect(result.valid).toBe(true);
+      expect(result.diagnostics.length).toBe(0);
+    });
+  });
+});
+