@vibe-lang/runtime 0.2.5

package/src/debug/test/handoff-manager.test.ts

@@ -0,0 +1,256 @@
+import { describe, test, expect, beforeEach } from 'bun:test';
+import {
+  createHandoffState,
+  shouldInitiateHandoff,
+  initiateHandoff,
+  completeHandoff,
+  shouldReturnControl,
+  returnToVibe,
+  handleTsStepIn,
+  handleTsStepOut,
+  getCurrentMode,
+  isInTsMode,
+  getSavedVibeState,
+} from '../handoff-manager';
+import { createDebugState } from '../state';
+import { createInitialState } from '../../runtime/state';
+import { parse } from '../../parser/parse';
+import { clearTsBlockMappings } from '../ts-source-map';
+
+describe('Handoff Manager', () => {
+  beforeEach(() => {
+    clearTsBlockMappings();
+  });
+
+  describe('createHandoffState', () => {
+    test('creates initial state in Vibe mode', () => {
+      const state = createHandoffState();
+
+      expect(getCurrentMode(state)).toBe('vibe');
+      expect(isInTsMode(state)).toBe(false);
+      expect(state.handoffInProgress).toBe(false);
+      expect(state.handoffReason).toBeNull();
+    });
+  });
+
+  describe('shouldInitiateHandoff', () => {
+    test('returns false for normal running state', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = createInitialState(ast);
+      const handoffState = createHandoffState();
+
+      const result = shouldInitiateHandoff(runtimeState, handoffState);
+      expect(result.shouldHandoff).toBe(false);
+      expect(result.reason).toBeNull();
+    });
+
+    test('returns false if already in TS mode', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = createInitialState(ast);
+      let handoffState = createHandoffState();
+
+      // Simulate being in TS mode
+      const debugState = createDebugState();
+      handoffState = initiateHandoff(
+        { ...runtimeState, status: 'awaiting_ts', pendingTS: { params: [], body: 'x', paramValues: [] } } as any,
+        debugState,
+        handoffState,
+        'ts_block'
+      );
+
+      const result = shouldInitiateHandoff(runtimeState, handoffState);
+      expect(result.shouldHandoff).toBe(false);
+    });
+  });
+
+  describe('initiateHandoff', () => {
+    test('switches to TS mode for ts_block', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = {
+        ...createInitialState(ast),
+        status: 'awaiting_ts' as const,
+        pendingTS: {
+          params: ['a'],
+          body: 'return a + 1',
+          paramValues: [5],
+          location: { file: '/test.vibe', line: 10, column: 5 },
+        },
+      };
+      const debugState = createDebugState();
+      const handoffState = createHandoffState();
+
+      const newState = initiateHandoff(runtimeState as any, debugState, handoffState, 'ts_block');
+
+      expect(newState.context.mode).toBe('typescript');
+      expect(newState.context.currentTsBlockId).toBeTruthy();
+      expect(newState.handoffInProgress).toBe(true);
+      expect(newState.handoffReason).toBe('ts_block');
+      expect(newState.savedVibeState).toBe(debugState);
+    });
+
+    test('switches to TS mode for ts_import', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = {
+        ...createInitialState(ast),
+        status: 'awaiting_ts' as const,
+        pendingImportedTsCall: {
+          funcName: 'calculate',
+          args: [1, 2],
+        },
+      };
+      const debugState = createDebugState();
+      const handoffState = createHandoffState();
+
+      const newState = initiateHandoff(runtimeState as any, debugState, handoffState, 'ts_import');
+
+      expect(newState.context.mode).toBe('typescript');
+      expect(newState.context.currentTsImport).toBe('calculate');
+      expect(newState.handoffReason).toBe('ts_import');
+    });
+  });
+
+  describe('completeHandoff', () => {
+    test('marks handoff as no longer in progress', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = {
+        ...createInitialState(ast),
+        status: 'awaiting_ts' as const,
+        pendingTS: { params: [], body: 'x', paramValues: [], location: { file: '', line: 1, column: 1 } },
+      };
+      const debugState = createDebugState();
+      let state = createHandoffState();
+
+      state = initiateHandoff(runtimeState as any, debugState, state, 'ts_block');
+      expect(state.handoffInProgress).toBe(true);
+
+      state = completeHandoff(state);
+      expect(state.handoffInProgress).toBe(false);
+      // Still in TS mode though
+      expect(state.context.mode).toBe('typescript');
+    });
+  });
+
+  describe('shouldReturnControl', () => {
+    test('returns false in Vibe mode', () => {
+      const state = createHandoffState();
+      expect(shouldReturnControl(state, 0)).toBe(false);
+    });
+
+    test('returns true in TS mode when call depth is zero', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = {
+        ...createInitialState(ast),
+        status: 'awaiting_ts' as const,
+        pendingTS: { params: [], body: 'x', paramValues: [], location: { file: '', line: 1, column: 1 } },
+      };
+      let state = createHandoffState();
+      state = initiateHandoff(runtimeState as any, createDebugState(), state, 'ts_block');
+
+      expect(shouldReturnControl(state, 0)).toBe(true);
+    });
+
+    test('returns false in TS mode when call depth is positive', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = {
+        ...createInitialState(ast),
+        status: 'awaiting_ts' as const,
+        pendingTS: { params: [], body: 'x', paramValues: [], location: { file: '', line: 1, column: 1 } },
+      };
+      let state = createHandoffState();
+      state = initiateHandoff(runtimeState as any, createDebugState(), state, 'ts_block');
+
+      expect(shouldReturnControl(state, 2)).toBe(false);
+    });
+  });
+
+  describe('returnToVibe', () => {
+    test('switches back to Vibe mode', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = {
+        ...createInitialState(ast),
+        status: 'awaiting_ts' as const,
+        pendingTS: { params: [], body: 'x', paramValues: [], location: { file: '', line: 1, column: 1 } },
+      };
+      let state = createHandoffState();
+      state = initiateHandoff(runtimeState as any, createDebugState(), state, 'ts_block');
+
+      state = returnToVibe(state);
+
+      expect(state.context.mode).toBe('vibe');
+      expect(state.handoffInProgress).toBe(false);
+      expect(state.handoffReason).toBeNull();
+      expect(state.savedVibeState).toBeNull();
+    });
+  });
+
+  describe('handleTsStepIn', () => {
+    test('increments TS call depth', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = {
+        ...createInitialState(ast),
+        status: 'awaiting_ts' as const,
+        pendingTS: { params: [], body: 'x', paramValues: [], location: { file: '', line: 1, column: 1 } },
+      };
+      let state = createHandoffState();
+      state = initiateHandoff(runtimeState as any, createDebugState(), state, 'ts_block');
+
+      expect(state.context.tsCallDepth).toBe(1);
+
+      state = handleTsStepIn(state);
+      expect(state.context.tsCallDepth).toBe(2);
+    });
+  });
+
+  describe('handleTsStepOut', () => {
+    test('decrements TS call depth', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = {
+        ...createInitialState(ast),
+        status: 'awaiting_ts' as const,
+        pendingTS: { params: [], body: 'x', paramValues: [], location: { file: '', line: 1, column: 1 } },
+      };
+      let state = createHandoffState();
+      state = initiateHandoff(runtimeState as any, createDebugState(), state, 'ts_block');
+      state = handleTsStepIn(state); // depth = 2
+
+      state = handleTsStepOut(state);
+      expect(state.context.tsCallDepth).toBe(1);
+      expect(state.context.mode).toBe('typescript');
+    });
+
+    test('returns to Vibe mode when depth reaches zero', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = {
+        ...createInitialState(ast),
+        status: 'awaiting_ts' as const,
+        pendingTS: { params: [], body: 'x', paramValues: [], location: { file: '', line: 1, column: 1 } },
+      };
+      let state = createHandoffState();
+      state = initiateHandoff(runtimeState as any, createDebugState(), state, 'ts_block');
+
+      state = handleTsStepOut(state); // depth goes to 0, exits TS mode
+
+      expect(state.context.mode).toBe('vibe');
+      expect(state.context.tsCallDepth).toBe(0);
+    });
+  });
+
+  describe('getSavedVibeState', () => {
+    test('returns saved state after handoff', () => {
+      const ast = parse('let x = 1');
+      const runtimeState = {
+        ...createInitialState(ast),
+        status: 'awaiting_ts' as const,
+        pendingTS: { params: [], body: 'x', paramValues: [], location: { file: '', line: 1, column: 1 } },
+      };
+      const debugState = createDebugState();
+      let state = createHandoffState();
+
+      state = initiateHandoff(runtimeState as any, debugState, state, 'ts_block');
+
+      const saved = getSavedVibeState(state);
+      expect(saved.debugState).toBe(debugState);
+      expect(saved.runtimeState).toBeDefined();
+    });
+  });
+});

package/src/debug/test/runner.test.ts

@@ -0,0 +1,256 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  initDebugSession,
+  debugStep,
+  debugContinue,
+  debugStepIn,
+  debugStepOver,
+  debugStepOut,
+} from '../runner';
+import { createDebugState, setBreakpoints, setStepMode } from '../state';
+import { createInitialState } from '../../runtime/state';
+import { parse } from '../../parser/parse';
+
+describe('Debug Runner', () => {
+  describe('initDebugSession', () => {
+    test('initializes debug session without stopOnEntry', () => {
+      const debugState = initDebugSession();
+
+      expect(debugState.paused).toBe(false);
+      expect(debugState.stopReason).toBeNull();
+    });
+
+    test('initializes debug session with stopOnEntry', () => {
+      const debugState = initDebugSession({ stopOnEntry: true });
+
+      expect(debugState.paused).toBe(true);
+      expect(debugState.stopReason).toBe('entry');
+    });
+  });
+
+  describe('debugStep', () => {
+    test('steps one instruction', () => {
+      const code = `
+let x = 1
+let y = 2
+`;
+      const ast = parse(code);
+      const runtimeState = createInitialState(ast);
+      const debugState = createDebugState();
+
+      const result = debugStep(runtimeState, debugState);
+
+      // Should have progressed
+      expect(result.runtimeState).toBeDefined();
+      expect(result.debugState).toBeDefined();
+    });
+
+    test('returns terminated event when complete', () => {
+      const code = 'let x = 1';
+      const ast = parse(code);
+      let runtimeState = createInitialState(ast);
+      let debugState = createDebugState();
+
+      // Run until complete
+      while (runtimeState.status !== 'completed' && runtimeState.status !== 'error') {
+        const result = debugStep(runtimeState, debugState);
+        runtimeState = result.runtimeState;
+        debugState = result.debugState;
+        if (result.event?.event === 'terminated') break;
+      }
+
+      expect(runtimeState.status).toBe('completed');
+    });
+
+    test('stops at breakpoint', () => {
+      const code = `
+let x = 1
+let y = 2
+let z = 3
+`;
+      const ast = parse(code, { file: '/test.vibe' });
+      let runtimeState = createInitialState(ast);
+      let debugState = createDebugState();
+
+      // Set breakpoint on line 3 (let y = 2)
+      const bpResult = setBreakpoints(debugState, '/test.vibe', [3]);
+      debugState = bpResult.debugState;
+
+      // Continue until we hit breakpoint or complete
+      const result = debugContinue(runtimeState, debugState);
+
+      // Should have stopped
+      if (result.event?.event === 'stopped') {
+        expect(result.event.body.reason).toBe('breakpoint');
+      }
+    });
+  });
+
+  describe('debugContinue', () => {
+    test('runs until completion when no breakpoints', () => {
+      const code = `
+let x = 1
+let y = 2
+`;
+      const ast = parse(code);
+      const runtimeState = createInitialState(ast);
+      const debugState = createDebugState();
+
+      const result = debugContinue(runtimeState, debugState);
+
+      // Should complete or await async
+      expect(['completed', 'awaiting_ai', 'awaiting_ts'].includes(result.runtimeState.status) || result.event?.event === 'terminated').toBe(true);
+    });
+  });
+
+  describe('debugStepIn', () => {
+    test('sets step into mode and steps', () => {
+      const code = 'let x = 1';
+      const ast = parse(code);
+      const runtimeState = createInitialState(ast);
+      const debugState = createDebugState();
+
+      const result = debugStepIn(runtimeState, debugState);
+
+      expect(result.runtimeState).toBeDefined();
+    });
+  });
+
+  describe('debugStepOver', () => {
+    test('sets step over mode and steps', () => {
+      const code = 'let x = 1';
+      const ast = parse(code);
+      const runtimeState = createInitialState(ast);
+      const debugState = createDebugState();
+
+      const result = debugStepOver(runtimeState, debugState);
+
+      expect(result.runtimeState).toBeDefined();
+    });
+  });
+
+  describe('debugStepOut', () => {
+    test('sets step out mode and continues', () => {
+      const code = `
+function foo() {
+  let x = 1
+  return x
+}
+foo()
+`;
+      const ast = parse(code);
+      const runtimeState = createInitialState(ast);
+      const debugState = createDebugState();
+
+      const result = debugStepOut(runtimeState, debugState);
+
+      expect(result.runtimeState).toBeDefined();
+    });
+  });
+});
+
+describe('Debug Events', () => {
+  test('emits stopped event at breakpoint', () => {
+    const code = `
+let x = 1
+let y = 2
+`;
+    const ast = parse(code, { file: '/test.vibe' });
+    let runtimeState = createInitialState(ast);
+    let debugState = createDebugState();
+
+    // Set breakpoint on line 3
+    const bpResult = setBreakpoints(debugState, '/test.vibe', [3]);
+    debugState = bpResult.debugState;
+
+    const result = debugContinue(runtimeState, debugState);
+
+    if (result.event) {
+      expect(result.event.type).toBe('event');
+      expect(['stopped', 'terminated']).toContain(result.event.event);
+    }
+  });
+
+  test('emits terminated event when complete', () => {
+    const code = 'let x = 1';
+    const ast = parse(code);
+    const runtimeState = createInitialState(ast);
+    const debugState = createDebugState();
+
+    const result = debugContinue(runtimeState, debugState);
+
+    expect(result.event?.event).toBe('terminated');
+  });
+});
+
+describe('Step Modes', () => {
+  test('step into pauses on each instruction', () => {
+    const code = `
+let x = 1
+let y = 2
+`;
+    const ast = parse(code);
+    let runtimeState = createInitialState(ast);
+    let debugState = setStepMode(createDebugState(), 'into');
+
+    // First step
+    let result = debugStep(runtimeState, debugState);
+
+    // Should pause (step mode triggers pause)
+    if (result.event?.event === 'stopped') {
+      expect(result.event.body.reason).toBe('step');
+    }
+  });
+});
+
+describe('Complex Programs', () => {
+  test('handles function calls', () => {
+    const code = `
+function add(a: number, b: number): number {
+  return a + b
+}
+let result = add(1, 2)
+`;
+    const ast = parse(code);
+    const runtimeState = createInitialState(ast);
+    const debugState = createDebugState();
+
+    const result = debugContinue(runtimeState, debugState);
+
+    expect(result.runtimeState.status).toBe('completed');
+  });
+
+  test('handles conditionals', () => {
+    const code = `
+let x = 10
+if x > 5 {
+  let y = "big"
+} else {
+  let y = "small"
+}
+`;
+    const ast = parse(code);
+    const runtimeState = createInitialState(ast);
+    const debugState = createDebugState();
+
+    const result = debugContinue(runtimeState, debugState);
+
+    expect(result.runtimeState.status).toBe('completed');
+  });
+
+  test('handles loops', () => {
+    const code = `
+let sum = 0
+for i in 1..3 {
+  sum = sum + i
+}
+`;
+    const ast = parse(code);
+    const runtimeState = createInitialState(ast);
+    const debugState = createDebugState();
+
+    const result = debugContinue(runtimeState, debugState);
+
+    expect(result.runtimeState.status).toBe('completed');
+  });
+});

package/src/debug/test/stack-merger.test.ts

@@ -0,0 +1,163 @@
+import { describe, test, expect } from 'bun:test';
+import {
+  createDebugExecutionContext,
+  enterTsBlock,
+  enterTsImport,
+  exitTsMode,
+  incrementTsCallDepth,
+  decrementTsCallDepth,
+  mergeStackFrames,
+  shouldReturnToVibe,
+} from '../stack-merger';
+import type { StackFrame } from '@vibe-lang/debug-core';
+
+describe('Debug Execution Context', () => {
+  describe('createDebugExecutionContext', () => {
+    test('creates initial context in Vibe mode', () => {
+      const context = createDebugExecutionContext();
+
+      expect(context.mode).toBe('vibe');
+      expect(context.tsCallDepth).toBe(0);
+      expect(context.vibeCallDepthOnTsEntry).toBe(0);
+      expect(context.currentTsBlockId).toBeNull();
+      expect(context.currentTsImport).toBeNull();
+    });
+  });
+
+  describe('enterTsBlock', () => {
+    test('switches to TS mode for ts block', () => {
+      let context = createDebugExecutionContext();
+      context = enterTsBlock(context, 'ts_block_1', 3);
+
+      expect(context.mode).toBe('typescript');
+      expect(context.tsCallDepth).toBe(1);
+      expect(context.vibeCallDepthOnTsEntry).toBe(3);
+      expect(context.currentTsBlockId).toBe('ts_block_1');
+      expect(context.currentTsImport).toBeNull();
+    });
+  });
+
+  describe('enterTsImport', () => {
+    test('switches to TS mode for imported function', () => {
+      let context = createDebugExecutionContext();
+      context = enterTsImport(context, 'myTsFunction', 2);
+
+      expect(context.mode).toBe('typescript');
+      expect(context.tsCallDepth).toBe(1);
+      expect(context.vibeCallDepthOnTsEntry).toBe(2);
+      expect(context.currentTsBlockId).toBeNull();
+      expect(context.currentTsImport).toBe('myTsFunction');
+    });
+  });
+
+  describe('exitTsMode', () => {
+    test('returns to Vibe mode', () => {
+      let context = createDebugExecutionContext();
+      context = enterTsBlock(context, 'ts_block_1', 3);
+      context = exitTsMode(context);
+
+      expect(context.mode).toBe('vibe');
+      expect(context.tsCallDepth).toBe(0);
+      expect(context.vibeCallDepthOnTsEntry).toBe(0);
+      expect(context.currentTsBlockId).toBeNull();
+    });
+  });
+
+  describe('incrementTsCallDepth', () => {
+    test('increments call depth', () => {
+      let context = createDebugExecutionContext();
+      context = enterTsBlock(context, 'ts_block_1', 2);
+      context = incrementTsCallDepth(context);
+
+      expect(context.tsCallDepth).toBe(2);
+    });
+  });
+
+  describe('decrementTsCallDepth', () => {
+    test('decrements call depth', () => {
+      let context = createDebugExecutionContext();
+      context = enterTsBlock(context, 'ts_block_1', 2);
+      context = incrementTsCallDepth(context); // depth = 2
+      context = decrementTsCallDepth(context);
+
+      expect(context.tsCallDepth).toBe(1);
+      expect(context.mode).toBe('typescript');
+    });
+
+    test('exits TS mode when depth reaches zero', () => {
+      let context = createDebugExecutionContext();
+      context = enterTsBlock(context, 'ts_block_1', 2);
+      context = decrementTsCallDepth(context); // depth = 0
+
+      expect(context.mode).toBe('vibe');
+      expect(context.tsCallDepth).toBe(0);
+    });
+  });
+});
+
+describe('Stack Frame Merging', () => {
+  const vibeFrames: StackFrame[] = [
+    { id: 0, name: 'main', source: { file: '/app.vibe', line: 1, column: 1 }, isVibeCode: true },
+    { id: 1, name: 'helper', source: { file: '/app.vibe', line: 10, column: 1 }, isVibeCode: true },
+  ];
+
+  const tsFrames: StackFrame[] = [
+    { id: 0, name: 'tsFunc', source: { file: '/utils.ts', line: 5, column: 1 }, isVibeCode: false },
+    { id: 1, name: 'innerTs', source: { file: '/utils.ts', line: 15, column: 1 }, isVibeCode: false },
+  ];
+
+  describe('mergeStackFrames', () => {
+    test('returns only Vibe frames in Vibe mode', () => {
+      const context = createDebugExecutionContext();
+      const merged = mergeStackFrames(vibeFrames, tsFrames, context);
+
+      expect(merged.length).toBe(2);
+      expect(merged.every(f => f.origin === 'vibe')).toBe(true);
+    });
+
+    test('merges TS and Vibe frames in TS mode', () => {
+      let context = createDebugExecutionContext();
+      context = enterTsBlock(context, 'ts_block_1', 1);
+
+      const merged = mergeStackFrames(vibeFrames, tsFrames, context);
+
+      // TS frames on top, then Vibe frames
+      expect(merged.length).toBeGreaterThan(0);
+      expect(merged[0].origin).toBe('typescript');
+      expect(merged[1].origin).toBe('typescript');
+    });
+
+    test('assigns sequential IDs to merged frames', () => {
+      let context = createDebugExecutionContext();
+      context = enterTsBlock(context, 'ts_block_1', 0);
+
+      const merged = mergeStackFrames(vibeFrames, tsFrames, context);
+
+      merged.forEach((frame, index) => {
+        expect(frame.id).toBe(index);
+      });
+    });
+  });
+});
+
+describe('shouldReturnToVibe', () => {
+  test('returns true when TS call depth is zero', () => {
+    let context = createDebugExecutionContext();
+    context = enterTsBlock(context, 'ts_block_1', 2);
+
+    expect(shouldReturnToVibe(context, 0)).toBe(true);
+  });
+
+  test('returns false when TS call depth is positive', () => {
+    let context = createDebugExecutionContext();
+    context = enterTsBlock(context, 'ts_block_1', 2);
+
+    expect(shouldReturnToVibe(context, 2)).toBe(false);
+  });
+
+  test('returns false in Vibe mode', () => {
+    const context = createDebugExecutionContext();
+
+    expect(shouldReturnToVibe(context, 0)).toBe(false);
+  });
+});