@holoscript/core 1.0.0-alpha.1 → 2.0.0

package/src/HoloScriptCodeParser.ts

@@ -67,6 +67,23 @@ export class HoloScriptCodeParser {
   private warnings: string[] = [];
   private tokens: Token[] = [];
   private position: number = 0;
+  private keywordSet: Set<string>;
+
+  constructor() {
+    // Pre-compute keyword set for O(1) lookup instead of O(n) array search
+    this.keywordSet = new Set([
+      'orb', 'function', 'connect', 'to', 'as', 'gate', 'stream', 'from', 'through', 'return',
+      'if', 'else', 'nexus', 'building', 'pillar', 'foundation',
+      'for', 'while', 'forEach', 'in', 'of', 'break', 'continue',
+      'import', 'export', 'module', 'use',
+      'type', 'interface', 'extends', 'implements',
+      'async', 'await', 'spawn', 'parallel',
+      'class', 'new', 'this', 'super', 'static', 'private', 'public',
+      'try', 'catch', 'finally', 'throw',
+      'const', 'let', 'var',
+      'animate', 'modify', 'pulse', 'move', 'show', 'hide',
+    ]);
+  }
 
   /**
    * Parse HoloScript code string into AST
@@ -132,25 +149,6 @@ export class HoloScriptCodeParser {
     let column = 1;
     let i = 0;
 
-    const keywords = [
-      'orb', 'function', 'connect', 'to', 'as', 'gate', 'stream', 'from', 'through', 'return',
-      'if', 'else', 'nexus', 'building', 'pillar', 'foundation',
-      // Phase 2: Loop constructs
-      'for', 'while', 'forEach', 'in', 'of', 'break', 'continue',
-      // Phase 2: Module system
-      'import', 'export', 'module', 'use',
-      // Phase 2: Type system
-      'type', 'interface', 'extends', 'implements',
-      // Phase 2: Async
-      'async', 'await', 'spawn', 'parallel',
-      // Phase 2: Object-oriented
-      'class', 'new', 'this', 'super', 'static', 'private', 'public',
-      // Phase 2: Error handling
-      'try', 'catch', 'finally', 'throw',
-      // Phase 2: Constants
-      'const', 'let', 'var',
-    ];
-
     while (i < code.length) {
       const char = code[i];
 
@@ -231,7 +229,7 @@ export class HoloScriptCodeParser {
           column++;
         }
 
-        const isKeyword = keywords.includes(ident.toLowerCase());
+        const isKeyword = this.keywordSet.has(ident.toLowerCase());
         tokens.push({
           type: isKeyword ? 'keyword' : 'identifier',
           value: ident,
@@ -341,10 +339,24 @@ export class HoloScriptCodeParser {
         case 'export':
           return this.parseExport();
         // Phase 2: Variable declarations
+        // UI Extensions
+        case 'ui2d':
+        case 'card':
+        case 'metric':
+        case 'button':
+        case 'row':
+        case 'col':
+        case 'text':
+           return this.parseUIElement();
         case 'const':
         case 'let':
         case 'var':
           return this.parseVariableDeclaration();
+        // DSL-first commands (Phase 54)
+        case 'animate':
+          return this.parseAnimate();
+        case 'modify':
+          return this.parseModify();
         default:
           this.advance();
           return null;
@@ -1055,6 +1067,119 @@ export class HoloScriptCodeParser {
     return null;
   }
 
+  /**
+   * Parse animate command: animate target property: "..." from: 0 to: 1 duration: 1000
+   */
+  private parseAnimate(): ASTNode | null {
+    this.expect('keyword', 'animate');
+    const target = this.expectIdentifier();
+    if (!target) return null;
+
+    const properties: Record<string, unknown> = {};
+
+    // Parse inline properties
+    while (this.position < this.tokens.length) {
+      this.skipNewlines();
+      const t = this.currentToken();
+      if (!t || t.type === 'newline' || (t.type === 'keyword' && this.keywordSet.has(t.value.toLowerCase()))) break;
+
+      const prop = this.parseProperty();
+      if (prop) {
+        properties[prop.key] = prop.value;
+      } else {
+        break;
+      }
+    }
+
+    return {
+      type: 'expression-statement',
+      expression: `animate("${target}", ${JSON.stringify(properties)})`,
+      position: { x: 0, y: 0, z: 0 },
+    } as ASTNode;
+  }
+
+  /**
+   * Parse modify command: modify target { prop: value }
+   */
+  private parseModify(): ASTNode | null {
+    this.expect('keyword', 'modify');
+    const target = this.expectIdentifier();
+    if (!target) return null;
+
+    const properties: Record<string, unknown> = {};
+
+    if (this.check('punctuation', '{')) {
+      this.advance();
+      while (!this.check('punctuation', '}') && this.position < this.tokens.length) {
+        this.skipNewlines();
+        if (this.check('punctuation', '}')) break;
+
+        const prop = this.parseProperty();
+        if (prop) {
+          properties[prop.key] = prop.value;
+        }
+        this.skipNewlines();
+      }
+      this.expect('punctuation', '}');
+    }
+
+    return {
+      type: 'expression-statement',
+      expression: `modify("${target}", ${JSON.stringify(properties)})`,
+      position: { x: 0, y: 0, z: 0 },
+    } as ASTNode;
+  }
+
+  /**
+   * Parse UI Element: ui2d dashboard#id { ... }
+   */
+  private parseUIElement(): ASTNode | null {
+      const typeToken = this.currentToken();
+      if (!typeToken) return null;
+      
+      const elementType = typeToken.value;
+      this.advance();
+      
+      let elementId = `${elementType}_${Date.now()}`;
+      
+      // Check for ID syntax
+      if (this.currentToken()?.type === 'punctuation' && this.currentToken()?.value === '#') {
+         this.advance(); 
+         const idToken = this.currentToken();
+         if (idToken) {
+             elementId = idToken.value;
+             this.advance();
+         }
+      } else if (this.currentToken()?.type === 'identifier' && this.currentToken()?.value.startsWith('#')) {
+          elementId = this.currentToken()?.value.slice(1) || elementId;
+          this.advance();
+      }
+      
+      const properties: Record<string, any> = {};
+      
+      if (this.check('punctuation', '{')) {
+          this.advance();
+          while (!this.check('punctuation', '}') && this.position < this.tokens.length) {
+              this.skipNewlines();
+              if (this.check('punctuation', '}')) break;
+              
+              const prop = this.parseProperty();
+              if (prop) {
+                  properties[prop.key] = prop.value;
+              }
+              this.skipNewlines();
+          }
+          this.expect('punctuation', '}');
+      }
+      
+      return {
+          type: 'ui2d', 
+          name: elementType,
+          properties: { id: elementId, ...properties },
+          position: { x: 0, y: 0, z: 0 }
+      } as ASTNode;
+  }
+
   private skipNewlines(): void {
     while (this.currentToken()?.type === 'newline') {
       this.advance();

package/src/HoloScriptDebugger.js

@@ -0,0 +1,458 @@
+/**
+ * HoloScript Debugger
+ *
+ * Step-through debugging with breakpoints, call stack inspection,
+ * and variable watch capabilities.
+ */
+import { HoloScriptRuntime } from './HoloScriptRuntime';
+import { HoloScriptCodeParser } from './HoloScriptCodeParser';
+/**
+ * HoloScript Debugger with breakpoints and step-through execution
+ */
+export class HoloScriptDebugger {
+    constructor(runtime) {
+        this.breakpoints = new Map();
+        this.callStack = [];
+        this.currentAST = [];
+        this.currentNodeIndex = 0;
+        this.frameIdCounter = 0;
+        this.breakpointIdCounter = 0;
+        this.eventHandlers = new Map();
+        this.state = {
+            status: 'stopped',
+            currentLine: 0,
+            currentColumn: 0,
+            currentNode: null,
+            callStack: [],
+            breakpoints: [],
+        };
+        this.runtime = runtime || new HoloScriptRuntime();
+        this.parser = new HoloScriptCodeParser();
+    }
+    /**
+     * Load source code for debugging
+     */
+    loadSource(code, file) {
+        const parseResult = this.parser.parse(code);
+        if (!parseResult.success) {
+            return {
+                success: false,
+                errors: parseResult.errors.map(e => `Line ${e.line}: ${e.message}`),
+            };
+        }
+        this.currentAST = parseResult.ast;
+        this.currentNodeIndex = 0;
+        this.state.status = 'stopped';
+        this.callStack = [];
+        // Store file reference in nodes
+        if (file) {
+            for (const node of this.currentAST) {
+                node.file = file;
+            }
+        }
+        return { success: true };
+    }
+    /**
+     * Set a breakpoint at a line
+     */
+    setBreakpoint(line, options = {}) {
+        const id = `bp_${++this.breakpointIdCounter}`;
+        const breakpoint = {
+            id,
+            line,
+            column: options.column,
+            condition: options.condition,
+            hitCount: 0,
+            enabled: options.enabled !== false,
+            file: options.file,
+        };
+        this.breakpoints.set(id, breakpoint);
+        this.updateBreakpointList();
+        return breakpoint;
+    }
+    /**
+     * Remove a breakpoint by ID
+     */
+    removeBreakpoint(id) {
+        const removed = this.breakpoints.delete(id);
+        if (removed) {
+            this.updateBreakpointList();
+        }
+        return removed;
+    }
+    /**
+     * Remove all breakpoints at a line
+     */
+    removeBreakpointsAtLine(line) {
+        let removed = 0;
+        for (const [id, bp] of this.breakpoints) {
+            if (bp.line === line) {
+                this.breakpoints.delete(id);
+                removed++;
+            }
+        }
+        if (removed > 0) {
+            this.updateBreakpointList();
+        }
+        return removed;
+    }
+    /**
+     * Toggle breakpoint enabled state
+     */
+    toggleBreakpoint(id) {
+        const bp = this.breakpoints.get(id);
+        if (bp) {
+            bp.enabled = !bp.enabled;
+            this.updateBreakpointList();
+            return bp.enabled;
+        }
+        return false;
+    }
+    /**
+     * Get all breakpoints
+     */
+    getBreakpoints() {
+        return Array.from(this.breakpoints.values());
+    }
+    /**
+     * Clear all breakpoints
+     */
+    clearBreakpoints() {
+        this.breakpoints.clear();
+        this.updateBreakpointList();
+    }
+    /**
+     * Start debugging from the beginning
+     */
+    async start() {
+        this.currentNodeIndex = 0;
+        this.callStack = [];
+        this.frameIdCounter = 0;
+        this.runtime.reset();
+        this.state.status = 'running';
+        await this.runUntilBreakpoint();
+    }
+    /**
+     * Continue execution until next breakpoint or end
+     */
+    async continue() {
+        if (this.state.status !== 'paused')
+            return;
+        this.state.status = 'running';
+        this.currentNodeIndex++;
+        await this.runUntilBreakpoint();
+    }
+    /**
+     * Step into the next node
+     */
+    async stepInto() {
+        if (this.state.status !== 'paused')
+            return;
+        this.state.status = 'stepping';
+        await this.executeStep('into');
+    }
+    /**
+     * Step over the current node
+     */
+    async stepOver() {
+        if (this.state.status !== 'paused')
+            return;
+        this.state.status = 'stepping';
+        await this.executeStep('over');
+    }
+    /**
+     * Step out of the current function
+     */
+    async stepOut() {
+        if (this.state.status !== 'paused')
+            return;
+        this.state.status = 'stepping';
+        await this.executeStep('out');
+    }
+    /**
+     * Stop debugging
+     */
+    stop() {
+        this.state.status = 'stopped';
+        this.callStack = [];
+        this.currentNodeIndex = 0;
+        this.emitEvent({ type: 'state-change', data: { status: 'stopped' } });
+    }
+    /**
+     * Pause execution
+     */
+    pause() {
+        if (this.state.status === 'running') {
+            this.state.status = 'paused';
+            this.emitEvent({ type: 'state-change', data: { status: 'paused' } });
+        }
+    }
+    /**
+     * Get current debug state
+     */
+    getState() {
+        return { ...this.state };
+    }
+    /**
+     * Get call stack
+     */
+    getCallStack() {
+        return [...this.callStack];
+    }
+    /**
+     * Get variables at a specific stack frame
+     */
+    getVariables(frameId) {
+        if (frameId !== undefined) {
+            const frame = this.callStack.find(f => f.id === frameId);
+            return frame?.variables || new Map();
+        }
+        // Return all variables from runtime context
+        return new Map(this.runtime.getContext().variables);
+    }
+    /**
+     * Evaluate an expression in the current context
+     */
+    async evaluate(expression) {
+        try {
+            // Try to evaluate as a variable lookup first
+            const varValue = this.runtime.getVariable(expression);
+            if (varValue !== undefined) {
+                return { value: varValue };
+            }
+            // Try to parse and execute as an expression
+            const parseResult = this.parser.parse(expression);
+            if (!parseResult.success) {
+                return { value: undefined, error: parseResult.errors[0]?.message };
+            }
+            // Execute the expression
+            const results = await this.runtime.executeProgram(parseResult.ast);
+            const lastResult = results[results.length - 1];
+            return { value: lastResult?.output };
+        }
+        catch (error) {
+            return { value: undefined, error: String(error) };
+        }
+    }
+    /**
+     * Set a watch expression
+     */
+    watch(expression) {
+        const id = `watch_${Date.now()}`;
+        return { id, expression };
+    }
+    /**
+     * Register an event handler
+     */
+    on(event, handler) {
+        if (!this.eventHandlers.has(event)) {
+            this.eventHandlers.set(event, []);
+        }
+        this.eventHandlers.get(event).push(handler);
+    }
+    /**
+     * Remove an event handler
+     */
+    off(event, handler) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+            const index = handlers.indexOf(handler);
+            if (index !== -1) {
+                handlers.splice(index, 1);
+            }
+        }
+    }
+    /**
+     * Get the underlying runtime
+     */
+    getRuntime() {
+        return this.runtime;
+    }
+    // Private methods
+    async runUntilBreakpoint() {
+        while (this.currentNodeIndex < this.currentAST.length) {
+            if (this.state.status === 'stopped')
+                break;
+            const node = this.currentAST[this.currentNodeIndex];
+            // Check for breakpoint
+            if (this.shouldBreakAt(node)) {
+                this.state.status = 'paused';
+                this.updateCurrentState(node);
+                const bp = this.findBreakpointAtLine(node.line ?? 0);
+                if (bp) {
+                    bp.hitCount++;
+                    this.emitEvent({
+                        type: 'breakpoint-hit',
+                        data: { breakpoint: bp, node, line: node.line ?? 0 },
+                    });
+                }
+                return;
+            }
+            // Execute the node
+            await this.executeNode(node);
+            this.currentNodeIndex++;
+        }
+        // Execution complete
+        this.state.status = 'stopped';
+        this.emitEvent({ type: 'state-change', data: { status: 'stopped', reason: 'complete' } });
+    }
+    async executeStep(mode) {
+        const startStackDepth = this.callStack.length;
+        if (this.currentNodeIndex >= this.currentAST.length) {
+            this.state.status = 'stopped';
+            return;
+        }
+        const node = this.currentAST[this.currentNodeIndex];
+        switch (mode) {
+            case 'into':
+                // Execute one node, stepping into function calls
+                await this.executeNode(node);
+                this.currentNodeIndex++;
+                break;
+            case 'over':
+                // Execute one node, treating function calls as single steps
+                await this.executeNode(node);
+                this.currentNodeIndex++;
+                break;
+            case 'out':
+                // Execute until we leave the current stack frame
+                while (this.currentNodeIndex < this.currentAST.length) {
+                    await this.executeNode(this.currentAST[this.currentNodeIndex]);
+                    this.currentNodeIndex++;
+                    if (this.callStack.length < startStackDepth) {
+                        break;
+                    }
+                }
+                break;
+        }
+        // Update state after step
+        if (this.currentNodeIndex < this.currentAST.length) {
+            this.state.status = 'paused';
+            this.updateCurrentState(this.currentAST[this.currentNodeIndex]);
+            this.emitEvent({
+                type: 'step-complete',
+                data: { mode, node: this.currentAST[this.currentNodeIndex] },
+            });
+        }
+        else {
+            this.state.status = 'stopped';
+            this.emitEvent({ type: 'state-change', data: { status: 'stopped', reason: 'complete' } });
+        }
+    }
+    async executeNode(node) {
+        // Push stack frame for functions
+        if (node.type === 'function') {
+            const funcNode = node;
+            this.pushStackFrame(funcNode.name, node);
+        }
+        try {
+            // Execute via runtime
+            const result = await this.runtime.executeNode(node);
+            if (!result.success && result.error) {
+                this.emitEvent({
+                    type: 'exception',
+                    data: { error: result.error, node, line: node.line },
+                });
+            }
+            if (result.output !== undefined) {
+                this.emitEvent({
+                    type: 'output',
+                    data: { output: result.output, node },
+                });
+            }
+        }
+        catch (error) {
+            this.emitEvent({
+                type: 'exception',
+                data: { error: String(error), node, line: node.line },
+            });
+        }
+        // Pop stack frame when function completes
+        if (node.type === 'function') {
+            this.popStackFrame();
+        }
+    }
+    shouldBreakAt(node) {
+        const line = node.line;
+        for (const bp of this.breakpoints.values()) {
+            if (!bp.enabled)
+                continue;
+            if (bp.line !== line)
+                continue;
+            // Check condition if present
+            if (bp.condition) {
+                try {
+                    const value = this.runtime.getVariable(bp.condition);
+                    if (!value)
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    findBreakpointAtLine(line) {
+        for (const bp of this.breakpoints.values()) {
+            if (bp.line === line && bp.enabled) {
+                return bp;
+            }
+        }
+        return null;
+    }
+    pushStackFrame(name, node) {
+        const frame = {
+            id: ++this.frameIdCounter,
+            name,
+            file: node.file,
+            line: node.line ?? 0,
+            column: node.column ?? 0,
+            variables: new Map(this.runtime.getContext().variables),
+            node,
+        };
+        this.callStack.push(frame);
+        this.state.callStack = [...this.callStack];
+    }
+    popStackFrame() {
+        const frame = this.callStack.pop();
+        this.state.callStack = [...this.callStack];
+        return frame;
+    }
+    updateCurrentState(node) {
+        this.state.currentLine = node.line ?? 0;
+        this.state.currentColumn = node.column ?? 0;
+        this.state.currentNode = node;
+    }
+    updateBreakpointList() {
+        this.state.breakpoints = Array.from(this.breakpoints.values());
+    }
+    emitEvent(event) {
+        const handlers = this.eventHandlers.get(event.type) || [];
+        for (const handler of handlers) {
+            try {
+                handler(event);
+            }
+            catch (error) {
+                console.error('Debug event handler error:', error);
+            }
+        }
+        // Also emit to 'all' handlers
+        const allHandlers = this.eventHandlers.get('all') || [];
+        for (const handler of allHandlers) {
+            try {
+                handler(event);
+            }
+            catch (error) {
+                console.error('Debug event handler error:', error);
+            }
+        }
+    }
+}
+/**
+ * Create a debugger instance
+ */
+export function createDebugger(runtime) {
+    return new HoloScriptDebugger(runtime);
+}