@holoscript/core 2.0.1 → 2.0.2

package/src/HoloScriptDebugger.js

@@ -1,458 +0,0 @@
-/**
- * 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);
-}