@vibe-lang/runtime 0.2.5

package/src/debug/test/advanced-features.test.ts

@@ -0,0 +1,300 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import {
+  createAdvancedDebugState,
+  setAdvancedBreakpoint,
+  removeAdvancedBreakpoint,
+  getAdvancedBreakpoint,
+  evaluateCondition,
+  checkHitCondition,
+  shouldBreakpointTrigger,
+  interpolateLogMessage,
+  addWatchExpression,
+  removeWatchExpression,
+  evaluateWatchExpressions,
+  setExceptionBreakpoints,
+  shouldBreakOnException,
+  flushLogOutput,
+} from '../advanced-features';
+import { createInitialState } from '../../runtime/state';
+import { parse } from '../../parser/parse';
+import { runUntilPause } from '../../runtime/step';
+
+describe('Advanced Debug Features', () => {
+  describe('createAdvancedDebugState', () => {
+    test('creates initial state', () => {
+      const state = createAdvancedDebugState();
+
+      expect(state.advancedBreakpoints.size).toBe(0);
+      expect(state.watchExpressions).toEqual([]);
+      expect(state.nextWatchId).toBe(1);
+      expect(state.exceptionBreakpoints.all).toBe(false);
+      expect(state.exceptionBreakpoints.uncaught).toBe(true);
+      expect(state.logOutput).toEqual([]);
+    });
+  });
+
+  describe('Conditional Breakpoints', () => {
+    test('setAdvancedBreakpoint with condition', () => {
+      let state = createAdvancedDebugState();
+
+      const { state: newState, breakpoint } = setAdvancedBreakpoint(
+        state,
+        '/test.vibe',
+        10,
+        { condition: 'x > 5' }
+      );
+
+      expect(breakpoint.condition).toBe('x > 5');
+      expect(breakpoint.line).toBe(10);
+      expect(newState.advancedBreakpoints.size).toBe(1);
+    });
+
+    test('getAdvancedBreakpoint retrieves breakpoint', () => {
+      let state = createAdvancedDebugState();
+      const { state: newState } = setAdvancedBreakpoint(state, '/test.vibe', 15, {
+        condition: 'y == 10',
+      });
+
+      const bp = getAdvancedBreakpoint(newState, '/test.vibe', 15);
+      expect(bp).toBeDefined();
+      expect(bp?.condition).toBe('y == 10');
+    });
+
+    test('removeAdvancedBreakpoint removes breakpoint', () => {
+      let state = createAdvancedDebugState();
+      const { state: state2 } = setAdvancedBreakpoint(state, '/test.vibe', 10, {});
+      const newState = removeAdvancedBreakpoint(state2, '/test.vibe', 10);
+
+      expect(getAdvancedBreakpoint(newState, '/test.vibe', 10)).toBeUndefined();
+    });
+  });
+
+  describe('evaluateCondition', () => {
+    test('returns true for no condition', () => {
+      const ast = parse('let x = 5');
+      const runtimeState = createInitialState(ast);
+
+      expect(evaluateCondition(undefined, runtimeState)).toBe(true);
+    });
+
+    test('evaluates simple comparisons', () => {
+      const ast = parse('let x = 10');
+      let runtimeState = createInitialState(ast);
+      runtimeState = runUntilPause(runtimeState);
+
+      // x should be 10
+      expect(evaluateCondition('x > 5', runtimeState)).toBe(true);
+      expect(evaluateCondition('x < 5', runtimeState)).toBe(false);
+      expect(evaluateCondition('x == 10', runtimeState)).toBe(true);
+    });
+  });
+
+  describe('Hit Count Conditions', () => {
+    test('checkHitCondition with >= operator', () => {
+      expect(checkHitCondition('>=5', 5)).toBe(true);
+      expect(checkHitCondition('>=5', 4)).toBe(false);
+      expect(checkHitCondition('>=5', 10)).toBe(true);
+    });
+
+    test('checkHitCondition with == operator', () => {
+      expect(checkHitCondition('==5', 5)).toBe(true);
+      expect(checkHitCondition('==5', 4)).toBe(false);
+      expect(checkHitCondition('=5', 5)).toBe(true);
+    });
+
+    test('checkHitCondition with modulo operator', () => {
+      expect(checkHitCondition('%3', 3)).toBe(true);
+      expect(checkHitCondition('%3', 6)).toBe(true);
+      expect(checkHitCondition('%3', 4)).toBe(false);
+    });
+
+    test('checkHitCondition with plain number', () => {
+      expect(checkHitCondition('5', 5)).toBe(true);
+      expect(checkHitCondition('5', 10)).toBe(true);
+      expect(checkHitCondition('5', 3)).toBe(false);
+    });
+  });
+
+  describe('Logpoints', () => {
+    test('setAdvancedBreakpoint with logMessage', () => {
+      let state = createAdvancedDebugState();
+
+      const { state: newState, breakpoint } = setAdvancedBreakpoint(
+        state,
+        '/test.vibe',
+        10,
+        { logMessage: 'Value is {x}' }
+      );
+
+      expect(breakpoint.logMessage).toBe('Value is {x}');
+    });
+
+    test('interpolateLogMessage replaces variables', () => {
+      const ast = parse('let x = 42\nlet y = "hello"');
+      let runtimeState = createInitialState(ast);
+      runtimeState = runUntilPause(runtimeState);
+
+      const message = interpolateLogMessage('x = {x}, y = {y}', runtimeState);
+      expect(message).toBe('x = 42, y = hello');
+    });
+
+    test('shouldBreakpointTrigger returns logMessage for logpoint', () => {
+      let state = createAdvancedDebugState();
+      const { state: state2 } = setAdvancedBreakpoint(state, '/test.vibe', 2, {
+        logMessage: 'Debug: {x}',
+      });
+
+      const ast = parse('let x = 100');
+      let runtimeState = createInitialState(ast);
+      runtimeState = runUntilPause(runtimeState);
+
+      const result = shouldBreakpointTrigger(state2, runtimeState, {
+        file: '/test.vibe',
+        line: 2,
+        column: 1,
+      });
+
+      expect(result.shouldBreak).toBe(false); // Logpoints don't break
+      expect(result.logMessage).toBe('Debug: 100');
+    });
+  });
+
+  describe('Watch Expressions', () => {
+    test('addWatchExpression adds watch', () => {
+      let state = createAdvancedDebugState();
+
+      const { state: newState, watch } = addWatchExpression(state, 'x + y');
+
+      expect(watch.expression).toBe('x + y');
+      expect(watch.id).toBe(1);
+      expect(newState.watchExpressions.length).toBe(1);
+    });
+
+    test('removeWatchExpression removes watch', () => {
+      let state = createAdvancedDebugState();
+      const { state: state2, watch } = addWatchExpression(state, 'x');
+      const newState = removeWatchExpression(state2, watch.id);
+
+      expect(newState.watchExpressions.length).toBe(0);
+    });
+
+    test('evaluateWatchExpressions evaluates all watches', () => {
+      let state = createAdvancedDebugState();
+      const { state: state2 } = addWatchExpression(state, 'x');
+      const { state: state3 } = addWatchExpression(state2, 'y');
+
+      const ast = parse('let x = 10\nlet y = 20');
+      let runtimeState = createInitialState(ast);
+      runtimeState = runUntilPause(runtimeState);
+
+      const newState = evaluateWatchExpressions(state3, runtimeState);
+
+      expect(newState.watchExpressions[0].lastValue).toBe('10');
+      expect(newState.watchExpressions[1].lastValue).toBe('20');
+    });
+  });
+
+  describe('Exception Breakpoints', () => {
+    test('setExceptionBreakpoints updates config', () => {
+      let state = createAdvancedDebugState();
+
+      state = setExceptionBreakpoints(state, { all: true });
+      expect(state.exceptionBreakpoints.all).toBe(true);
+
+      state = setExceptionBreakpoints(state, { filters: ['TypeError'] });
+      expect(state.exceptionBreakpoints.filters).toEqual(['TypeError']);
+    });
+
+    test('shouldBreakOnException respects all flag', () => {
+      let state = createAdvancedDebugState();
+      state = setExceptionBreakpoints(state, { all: true });
+
+      expect(shouldBreakOnException(state, new Error('test'), true)).toBe(true);
+      expect(shouldBreakOnException(state, new Error('test'), false)).toBe(true);
+    });
+
+    test('shouldBreakOnException respects uncaught flag', () => {
+      let state = createAdvancedDebugState();
+      state = setExceptionBreakpoints(state, { all: false, uncaught: true });
+
+      expect(shouldBreakOnException(state, new Error('test'), true)).toBe(false);
+      expect(shouldBreakOnException(state, new Error('test'), false)).toBe(true);
+    });
+
+    test('shouldBreakOnException respects filters', () => {
+      let state = createAdvancedDebugState();
+      state = setExceptionBreakpoints(state, {
+        all: false,
+        uncaught: false,
+        filters: ['TypeError'],
+      });
+
+      expect(shouldBreakOnException(state, new TypeError('test'), true)).toBe(true);
+      expect(shouldBreakOnException(state, new Error('test'), true)).toBe(false);
+    });
+  });
+
+  describe('Log Output', () => {
+    test('flushLogOutput returns and clears logs', () => {
+      let state = createAdvancedDebugState();
+      const { state: state2 } = setAdvancedBreakpoint(state, '/test.vibe', 1, {
+        logMessage: 'Log 1',
+      });
+
+      const ast = parse('let x = 1');
+      let runtimeState = createInitialState(ast);
+
+      // Trigger the logpoint
+      const { newState: state3 } = shouldBreakpointTrigger(state2, runtimeState, {
+        file: '/test.vibe',
+        line: 1,
+        column: 1,
+      });
+
+      const { state: state4, logs } = flushLogOutput(state3);
+
+      expect(logs.length).toBe(1);
+      expect(logs[0]).toBe('Log 1');
+      expect(state4.logOutput.length).toBe(0);
+    });
+  });
+
+  describe('shouldBreakpointTrigger', () => {
+    test('increments hit count', () => {
+      let state = createAdvancedDebugState();
+      const { state: state2 } = setAdvancedBreakpoint(state, '/test.vibe', 1, {});
+
+      const ast = parse('let x = 1');
+      const runtimeState = createInitialState(ast);
+      const location = { file: '/test.vibe', line: 1, column: 1 };
+
+      let { newState: state3 } = shouldBreakpointTrigger(state2, runtimeState, location);
+      expect(getAdvancedBreakpoint(state3, '/test.vibe', 1)?.hitCount).toBe(1);
+
+      let { newState: state4 } = shouldBreakpointTrigger(state3, runtimeState, location);
+      expect(getAdvancedBreakpoint(state4, '/test.vibe', 1)?.hitCount).toBe(2);
+    });
+
+    test('respects hit condition', () => {
+      let state = createAdvancedDebugState();
+      const { state: state2 } = setAdvancedBreakpoint(state, '/test.vibe', 1, {
+        hitCondition: '>=3',
+      });
+
+      const ast = parse('let x = 1');
+      const runtimeState = createInitialState(ast);
+      const location = { file: '/test.vibe', line: 1, column: 1 };
+
+      // First two hits should not break
+      let { shouldBreak: b1, newState: s1 } = shouldBreakpointTrigger(state2, runtimeState, location);
+      expect(b1).toBe(false);
+
+      let { shouldBreak: b2, newState: s2 } = shouldBreakpointTrigger(s1, runtimeState, location);
+      expect(b2).toBe(false);
+
+      // Third hit should break
+      let { shouldBreak: b3 } = shouldBreakpointTrigger(s2, runtimeState, location);
+      expect(b3).toBe(true);
+    });
+  });
+});

package/src/debug/test/e2e.test.ts

@@ -0,0 +1,218 @@
+import { describe, test, expect } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { createInitialState } from '../../runtime/state';
+import { loadImports } from '../../runtime/modules';
+import {
+  createDebugState,
+  setBreakpoints,
+  getStackTrace,
+  getScopes,
+  getVariables,
+  getCurrentLocation,
+} from '../state';
+import { runWithDebug, createOutputEvent } from '../runner';
+import type { RuntimeEvent } from '@vibe-lang/debug-core';
+import type { AIProvider, AIExecutionResult } from '../../runtime';
+
+// Mock AI provider for testing
+const mockAIProvider: AIProvider = {
+  async execute(prompt: string): Promise<AIExecutionResult> {
+    return { value: `Mock response to: ${prompt.slice(0, 50)}...` };
+  },
+  async generateCode(prompt: string): Promise<AIExecutionResult> {
+    return { value: '// mock code' };
+  },
+  async askUser(prompt: string): Promise<string> {
+    return 'mock user input';
+  },
+};
+
+describe('End-to-End Debug Session', () => {
+  test('full debug session with breakpoints', async () => {
+    const code = `
+let x = 10
+let y = 20
+let z = x + y
+`;
+    const ast = parse(code, { file: '/test.vibe' });
+    let runtimeState = createInitialState(ast);
+    let debugState = createDebugState();
+
+    // Set breakpoint on line 3 (let y = 20)
+    const bpResult = setBreakpoints(debugState, '/test.vibe', [3]);
+    debugState = bpResult.debugState;
+
+    // Collect events
+    const events: RuntimeEvent[] = [];
+    const onEvent = (event: RuntimeEvent) => events.push(event);
+
+    // Run with debug
+    const result = await runWithDebug(runtimeState, debugState, mockAIProvider, onEvent);
+
+    // Should have stopped at breakpoint or completed
+    expect(result.runtimeState).toBeDefined();
+    expect(result.debugState).toBeDefined();
+  });
+
+  test('stop on entry', async () => {
+    const code = 'let x = 1';
+    const ast = parse(code, { file: '/test.vibe' });
+    const runtimeState = createInitialState(ast);
+    const debugState = createDebugState({ stopOnEntry: true });
+
+    const events: RuntimeEvent[] = [];
+    const result = await runWithDebug(runtimeState, debugState, mockAIProvider, (e) => events.push(e));
+
+    // Should be paused at entry
+    expect(result.debugState.paused).toBe(true);
+    expect(result.debugState.stopReason).toBe('entry');
+  });
+
+  test('inspect variables at breakpoint', async () => {
+    const code = `
+let x = 42
+let y = "hello"
+let z = x
+`;
+    const ast = parse(code, { file: '/test.vibe' });
+    let runtimeState = createInitialState(ast);
+    let debugState = createDebugState();
+
+    // Set breakpoint on line 4 (after x and y are set)
+    const bpResult = setBreakpoints(debugState, '/test.vibe', [4]);
+    debugState = bpResult.debugState;
+
+    const events: RuntimeEvent[] = [];
+    const result = await runWithDebug(runtimeState, debugState, mockAIProvider, (e) => events.push(e));
+
+    runtimeState = result.runtimeState;
+    debugState = result.debugState;
+
+    // Get stack trace
+    const { stackFrames } = getStackTrace(runtimeState);
+    expect(stackFrames.length).toBeGreaterThan(0);
+
+    // Get scopes
+    const scopeResult = getScopes(debugState, runtimeState, 0);
+    debugState = scopeResult.debugState;
+    expect(scopeResult.scopes.length).toBeGreaterThan(0);
+
+    // Get local variables
+    const localScope = scopeResult.scopes.find(s => s.type === 'local');
+    if (localScope) {
+      const varResult = getVariables(debugState, runtimeState, localScope.variablesReference);
+      expect(Array.isArray(varResult.variables)).toBe(true);
+    }
+  });
+
+  test('step through function calls', async () => {
+    const code = `
+function double(n: number): number {
+  return n * 2
+}
+
+let x = 5
+let y = double(x)
+`;
+    const ast = parse(code, { file: '/test.vibe' });
+    let runtimeState = createInitialState(ast);
+    let debugState = createDebugState({ stopOnEntry: true });
+
+    const events: RuntimeEvent[] = [];
+    let result = await runWithDebug(runtimeState, debugState, mockAIProvider, (e) => events.push(e));
+
+    // Should stop on entry
+    expect(result.debugState.paused).toBe(true);
+
+    // Continue to completion
+    debugState = { ...result.debugState, paused: false, stepMode: 'none' as const, running: true };
+    result = await runWithDebug(result.runtimeState, debugState, mockAIProvider, (e) => events.push(e));
+
+    // Should complete
+    expect(result.runtimeState.status).toBe('completed');
+  });
+
+  test('handles AI calls during debug', async () => {
+    const code = `
+let question = "What is 2+2?"
+let answer = vibe "{question}"
+`;
+    const ast = parse(code, { file: '/test.vibe' });
+    let runtimeState = createInitialState(ast);
+    const debugState = createDebugState();
+
+    const events: RuntimeEvent[] = [];
+    const result = await runWithDebug(runtimeState, debugState, mockAIProvider, (e) => events.push(e));
+
+    // Debug runner should execute without throwing
+    // The exact final status depends on runtime behavior with mock AI
+    expect(result.runtimeState).toBeDefined();
+    expect(result.debugState).toBeDefined();
+    // Should reach some terminal state (completed, error, or awaiting)
+    expect(['completed', 'awaiting_ai', 'error'].includes(result.runtimeState.status)).toBe(true);
+  });
+
+  test('multiple breakpoints', async () => {
+    const code = `
+let a = 1
+let b = 2
+let c = 3
+let d = 4
+`;
+    const ast = parse(code, { file: '/test.vibe' });
+    let runtimeState = createInitialState(ast);
+    let debugState = createDebugState();
+
+    // Set breakpoints on lines 2 and 4
+    const bpResult = setBreakpoints(debugState, '/test.vibe', [2, 4]);
+    debugState = bpResult.debugState;
+
+    const events: RuntimeEvent[] = [];
+    const stoppedEvents: RuntimeEvent[] = [];
+
+    // First run - should stop at first breakpoint
+    let result = await runWithDebug(runtimeState, debugState, mockAIProvider, (e) => {
+      events.push(e);
+      if (e.event === 'stopped') stoppedEvents.push(e);
+    });
+
+    // Should have some events
+    expect(events.length).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe('Debug Protocol Messages', () => {
+  test('createOutputEvent creates proper event', () => {
+    const event = createOutputEvent('Hello World', 'stdout');
+
+    expect(event.type).toBe('event');
+    expect(event.event).toBe('output');
+    expect(event.body.output).toBe('Hello World');
+    expect(event.body.category).toBe('stdout');
+  });
+
+  test('createOutputEvent defaults to stdout', () => {
+    const event = createOutputEvent('Test output');
+
+    expect(event.body.category).toBe('stdout');
+  });
+});
+
+describe('Location Tracking', () => {
+  test('getCurrentLocation returns location from runtime state', () => {
+    const code = `
+let x = 1
+let y = 2
+`;
+    const ast = parse(code, { file: '/test.vibe' });
+    const runtimeState = createInitialState(ast);
+
+    const location = getCurrentLocation(runtimeState);
+
+    // May or may not have location depending on state
+    if (location) {
+      expect(typeof location.line).toBe('number');
+      expect(typeof location.column).toBe('number');
+    }
+  });
+});