@vibe-lang/runtime 0.2.5

package/src/runtime/test/e2e.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from 'bun:test';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { parse } from '../../parser/parse';
+import { createInitialState } from '../state';
+import { runWithMockAI } from './helpers';
+
+// Get the package root directory (relative to this test file)
+// src/runtime/test -> runtime -> src -> runtime (package root)
+const packageRoot = join(import.meta.dir, '..', '..', '..');
+
+// Helper to load and run a vibe script file
+function runVibeScript(
+  filename: string,
+  aiMockResponses: string | Record<string, string>
+) {
+  const scriptPath = join(packageRoot, 'tests', 'fixtures', filename);
+  const source = readFileSync(scriptPath, 'utf-8');
+  const ast = parse(source);
+  const state = createInitialState(ast);
+  return runWithMockAI(state, aiMockResponses);
+}
+
+describe('End-to-End Vibe Scripts', () => {
+  test('simple-greeting.vibe - basic AI call with interpolation', () => {
+    // With unified interpolation, {name} in prompt strings is left as a reference
+    // The AI sees the literal {name} and gets the value through context
+    const finalState = runVibeScript('simple-greeting.vibe', {
+      'Generate a friendly greeting for {name}': 'Hello Alice! Welcome!',
+    });
+
+    expect(finalState.status).toBe('completed');
+    // AI results are AIResultObject - access .value for primitive
+    expect(finalState.lastResult.value).toBe('Hello Alice! Welcome!');
+  });
+
+  test('function-call.vibe - functions with multiple AI calls', () => {
+    // First prompt: aiPrompt is a regular string variable, {topic} expands to value
+    // Second prompt: directly in vibe expression, {content} is left as reference
+    const finalState = runVibeScript('function-call.vibe', {
+      'Write a short story about a brave knight':
+        'Once upon a time, a brave knight saved the kingdom.',
+      'Summarize this: {content}': 'Knight saves kingdom.',
+    });
+
+    expect(finalState.status).toBe('completed');
+    // AI results are AIResultObject - access .value for primitive
+    expect(finalState.lastResult.value).toBe('Knight saves kingdom.');
+  });
+
+  test('conditional-logic.vibe - if statement with AI call', () => {
+    const finalState = runVibeScript('conditional-logic.vibe', {
+      'Generate a premium greeting': 'Welcome, valued premium member!',
+    });
+
+    expect(finalState.status).toBe('completed');
+    // VibeValue: access .value for the primitive
+    expect(finalState.lastResult.value).toBe('Welcome, valued premium member!');
+  });
+
+  test('template-literals.vibe - template literal interpolation with AI', () => {
+    // {fullName} is left as reference in prompt (vibe expression)
+    const finalState = runVibeScript('template-literals.vibe', {
+      'Generate a welcome message for {fullName}':
+        'Welcome to our platform, John Doe!',
+    });
+
+    expect(finalState.status).toBe('completed');
+    // AI results are AIResultObject - access .value for primitive
+    expect(finalState.lastResult.value).toBe('Welcome to our platform, John Doe!');
+  });
+
+  test('multiple-ai-calls.vibe - sequential AI calls with data flow', () => {
+    // {topic}, {overview}, {details} are left as references in prompts
+    const finalState = runVibeScript('multiple-ai-calls.vibe', {
+      'Give a one-sentence overview of {topic}':
+        'Machine learning is AI that learns from data.',
+      'Expand on this: {overview}':
+        'Machine learning is a subset of artificial intelligence that enables systems to learn and improve from experience without being explicitly programmed.',
+      'Summarize in 5 words: {details}':
+        'AI learns from data automatically',
+    });
+
+    expect(finalState.status).toBe('completed');
+    // AI results are AIResultObject - access .value for primitive
+    expect(finalState.lastResult.value).toBe('AI learns from data automatically');
+  });
+});

package/src/runtime/test/error-locations/error-locations.test.ts

@@ -0,0 +1,80 @@
+import { describe, expect, test } from 'bun:test';
+import { resolve, dirname } from 'path';
+import { parse } from '../../../parser/parse';
+import { Runtime, type AIProvider } from '../../index';
+import { loadImports } from '../../modules';
+import { createInitialState } from '../../state';
+import { runUntilPause } from '../../step';
+
+const testDir = dirname(import.meta.path);
+
+// Mock AI provider for testing
+const mockProvider: AIProvider = {
+  execute: async () => ({ value: '' }),
+  generateCode: async () => ({ value: '' }),
+  askUser: async () => '',
+};
+
+describe('Runtime Error Locations with File Paths', () => {
+  test('error in main file shows correct file and line', async () => {
+    const filePath = resolve(testDir, 'main-error.vibe');
+    const source = await Bun.file(filePath).text();
+    const ast = parse(source, { file: filePath });
+
+    const runtime = new Runtime(ast, mockProvider, { basePath: filePath });
+
+    try {
+      await runtime.run();
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+      const err = e as Error & { location?: { line: number; column: number; file?: string } };
+      expect(err.location).toBeDefined();
+      expect(err.location?.line).toBe(3); // let bad: boolean = "not a boolean"
+      expect(err.location?.file).toBe(filePath);
+    }
+  });
+
+  test('error in imported file shows correct file and line', async () => {
+    const mainPath = resolve(testDir, 'main-import-error.vibe');
+    const source = await Bun.file(mainPath).text();
+    const ast = parse(source, { file: mainPath });
+
+    // Load imports
+    let state = createInitialState(ast);
+    state = await loadImports(state, mainPath);
+
+    // Run until error
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('error');
+    expect(state.error).toContain('expected number');
+
+    // Check the error object has the correct location
+    const err = state.errorObject as Error & { location?: { line: number; column: number; file?: string } };
+    expect(err).toBeDefined();
+    expect(err.location).toBeDefined();
+    expect(err.location?.line).toBe(3); // let invalid: number = "not a number"
+    expect(err.location?.file).toBe('./utils/helper.vibe');
+  });
+
+  test('error format() includes file path', async () => {
+    const filePath = resolve(testDir, 'main-error.vibe');
+    const source = await Bun.file(filePath).text();
+    const ast = parse(source, { file: filePath });
+
+    const runtime = new Runtime(ast, mockProvider, { basePath: filePath });
+
+    try {
+      await runtime.run();
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      const err = e as Error & { format?: () => string };
+      expect(err.format).toBeDefined();
+      const formatted = err.format!();
+      // Should include file path and line number
+      expect(formatted).toContain(filePath);
+      expect(formatted).toContain(':3:');
+    }
+  });
+});

package/src/runtime/test/error-locations/main-error.vibe

@@ -0,0 +1,4 @@
+let first = "ok"
+let second = "also ok"
+let bad: boolean = "not a boolean"
+let fourth = "never reached"

package/src/runtime/test/error-locations/main-import-error.vibe

@@ -0,0 +1,3 @@
+import { processData } from "./utils/helper.vibe"
+
+let result = processData()

package/src/runtime/test/error-locations/utils/helper.vibe

@@ -0,0 +1,5 @@
+export function processData(): text {
+  let valid = "some text"
+  let invalid: number = "not a number"
+  return valid
+}

package/src/runtime/test/for-in.test.ts

@@ -0,0 +1,312 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { createInitialState, runUntilPause } from '../index';
+
+describe('Runtime For-In Loop', () => {
+  // ============================================================================
+  // Basic array iteration
+  // ============================================================================
+
+  test('for-in iterates over string array', () => {
+    const ast = parse(`
+      let items = ["a", "b", "c"]
+      let result = ""
+      for item in items {
+        result = result
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+  });
+
+  test('for-in iterates over number array', () => {
+    const ast = parse(`
+      let sum: number = 0
+      for n in [1, 2, 3] {
+        sum = ts(sum, n) { return sum + n }
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('awaiting_ts');
+  });
+
+  // ============================================================================
+  // Range iteration with .. operator
+  // ============================================================================
+
+  test('range operator 2..5 creates [2,3,4,5]', () => {
+    const ast = parse(`
+      let range = 2..5
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['range'].value).toEqual([2, 3, 4, 5]);
+  });
+
+  test('range operator with variables', () => {
+    const ast = parse(`
+      let start: number = 1
+      let end: number = 3
+      let range = start..end
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['range'].value).toEqual([1, 2, 3]);
+  });
+
+  test('range operator with negative to positive', () => {
+    const ast = parse(`
+      let range = -3..4
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['range'].value).toEqual([-3, -2, -1, 0, 1, 2, 3, 4]);
+  });
+
+  test('range operator with negative to negative', () => {
+    const ast = parse(`
+      let range = -5..-2
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['range'].value).toEqual([-5, -4, -3, -2]);
+  });
+
+  test('range operator with variable bounds (start > end at runtime) produces empty array', () => {
+    // When bounds are variables, we can't check at compile time
+    // so runtime produces empty array for start > end
+    const ast = parse(`
+      let start: number = 5
+      let end: number = 2
+      let range = start..end
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['range'].value).toEqual([]);
+  });
+
+  test('range operator same start and end produces single element', () => {
+    const ast = parse(`
+      let range = 3..3
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['range'].value).toEqual([3]);
+  });
+
+  test('for-in with range operator', () => {
+    const ast = parse(`
+      let visited = false
+      for i in 1..3 {
+        visited = true
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['visited'].value).toBe(true);
+  });
+
+  // ============================================================================
+  // Range iteration with single number (for i in N)
+  // ============================================================================
+
+  test('for-in with number creates inclusive range (1 to N)', () => {
+    const ast = parse(`
+      let count: number = 0
+      for i in 3 {
+        count = ts(count) { return count + 1 }
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    // First iteration pauses for ts eval
+    expect(state.status).toBe('awaiting_ts');
+  });
+
+  test('for-in with zero iterations', () => {
+    const ast = parse(`
+      let executed = false
+      for i in 0 {
+        executed = true
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    expect(state.callStack[0].locals['executed'].value).toBe(false);
+  });
+
+  // ============================================================================
+  // Loop variable scoping
+  // ============================================================================
+
+  test('loop variable is accessible inside loop', () => {
+    const ast = parse(`
+      let captured = ""
+      for item in ["test"] {
+        captured = item
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    expect(state.callStack[0].locals['captured'].value).toBe('test');
+  });
+
+  test('loop variable is cleaned up after loop', () => {
+    const ast = parse(`
+      for item in ["a", "b"] {
+        let temp = item
+      }
+      let outside = "done"
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    // 'item' and 'temp' should not be visible
+    expect(state.callStack[0].locals['item']).toBeUndefined();
+    expect(state.callStack[0].locals['temp']).toBeUndefined();
+    expect(state.callStack[0].locals['outside'].value).toBe('done');
+  });
+
+  // ============================================================================
+  // Empty array
+  // ============================================================================
+
+  test('for-in with empty array does nothing', () => {
+    const ast = parse(`
+      let executed = false
+      for item in [] {
+        executed = true
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    expect(state.callStack[0].locals['executed'].value).toBe(false);
+  });
+
+  // ============================================================================
+  // Nested loops
+  // ============================================================================
+
+  test('nested for-in loops', () => {
+    const ast = parse(`
+      let count: number = 0
+      for i in 2 {
+        for j in 2 {
+          count = ts(count) { return count + 1 }
+        }
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    // First iteration of inner loop pauses for ts eval
+    expect(state.status).toBe('awaiting_ts');
+  });
+});
+
+describe('Runtime For-In Error Cases', () => {
+  test('for-in with non-integer range throws error', () => {
+    const ast = parse(`
+      for i in 3.5 {
+        let x = i
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('error');
+    expect(state.error).toContain('integer');
+  });
+
+  test('for-in with negative range throws error', () => {
+    const ast = parse(`
+      for i in -3 {
+        let x = i
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('error');
+    expect(state.error).toContain('non-negative');
+  });
+
+  test('for-in with non-integer range bounds throws error', () => {
+    const ast = parse(`
+      for i in 1.5..5 {
+        let x = i
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('error');
+    expect(state.error).toContain('integer');
+  });
+
+  test('[x, y] is treated as a plain array, not a range', () => {
+    // Explicit array literal [2, 5] should iterate as a 2-element array,
+    // NOT be interpreted as a range 2..5 = [2,3,4,5]
+    // The .. operator now handles ranges explicitly
+    const ast = parse(`
+      let visited = false
+      for i in [2, 5] {
+        visited = true
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('completed');
+    const frame = state.callStack[0];
+    expect(frame.locals['visited'].value).toBe(true);
+  });
+
+  test('for-in with string throws error', () => {
+    const ast = parse(`
+      let x = "not an array"
+      for i in x {
+        let y = i
+      }
+    `);
+    let state = createInitialState(ast);
+    state = runUntilPause(state);
+
+    expect(state.status).toBe('error');
+    expect(state.error).toContain('Cannot iterate');
+    expect(state.error).toContain('string');
+  });
+});

package/src/runtime/test/helpers.ts

@@ -0,0 +1,69 @@
+import type { RuntimeState } from '../types';
+import { resumeWithAIResponse, resumeWithUserInput } from '../state';
+import { runUntilPause } from '../step';
+
+// Create a mock AI runner that responds with predefined responses
+export function createMockAIRunner(responses: Record<string, string> | string) {
+  return function mockAI(state: RuntimeState): RuntimeState {
+    if (state.status !== 'awaiting_ai') return state;
+
+    const response =
+      typeof responses === 'string'
+        ? responses
+        : responses[state.pendingAI?.prompt ?? ''] ?? 'mock response';
+
+    return resumeWithAIResponse(state, response);
+  };
+}
+
+// Create a mock user input runner
+export function createMockUserRunner(responses: Record<string, string> | string) {
+  return function mockUser(state: RuntimeState): RuntimeState {
+    if (state.status !== 'awaiting_user') return state;
+
+    const response =
+      typeof responses === 'string'
+        ? responses
+        : responses[state.pendingAI?.prompt ?? ''] ?? 'mock input';
+
+    return resumeWithUserInput(state, response);
+  };
+}
+
+// Run a program with mock AI responses until completion or error
+export function runWithMockAI(
+  state: RuntimeState,
+  mockResponse: string | Record<string, string>
+): RuntimeState {
+  const mockAI = createMockAIRunner(mockResponse);
+  let current = runUntilPause(state);
+
+  while (current.status === 'awaiting_ai') {
+    current = mockAI(current);
+    current = runUntilPause(current);
+  }
+
+  return current;
+}
+
+// Run a program with both mock AI and user responses
+export function runWithMocks(
+  state: RuntimeState,
+  aiResponses: string | Record<string, string>,
+  userResponses: string | Record<string, string>
+): RuntimeState {
+  const mockAI = createMockAIRunner(aiResponses);
+  const mockUser = createMockUserRunner(userResponses);
+  let current = runUntilPause(state);
+
+  while (current.status === 'awaiting_ai' || current.status === 'awaiting_user') {
+    if (current.status === 'awaiting_ai') {
+      current = mockAI(current);
+    } else {
+      current = mockUser(current);
+    }
+    current = runUntilPause(current);
+  }
+
+  return current;
+}