@vibe-lang/runtime 0.2.5

package/src/runtime/test/async-parallel-timing.test.ts

@@ -0,0 +1,546 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { Runtime, type AIProvider, type AIExecutionResult } from '../index';
+
+// Mock AI provider that uses delays to simulate network latency
+function createDelayedMockAI(delayMs: number, responseValue: unknown = 'response'): AIProvider {
+  return {
+    async execute(prompt: string): Promise<AIExecutionResult> {
+      await Bun.sleep(delayMs);
+      return { value: responseValue };
+    },
+    async generateCode(prompt: string): Promise<AIExecutionResult> {
+      await Bun.sleep(delayMs);
+      return { value: `let x = 1;` };
+    },
+    async askUser(prompt: string): Promise<string> {
+      return 'user input';
+    },
+  };
+}
+
+// Mock AI provider that returns different values based on prompt
+function createMultiResponseMockAI(delayMs: number, responses: Record<string, unknown>): AIProvider {
+  return {
+    async execute(prompt: string): Promise<AIExecutionResult> {
+      await Bun.sleep(delayMs);
+      // Find matching response key in prompt
+      for (const [key, value] of Object.entries(responses)) {
+        if (prompt.includes(key)) {
+          return { value };
+        }
+      }
+      return { value: 'default' };
+    },
+    async generateCode(prompt: string): Promise<AIExecutionResult> {
+      await Bun.sleep(delayMs);
+      return { value: `let x = 1;` };
+    },
+    async askUser(prompt: string): Promise<string> {
+      return 'user input';
+    },
+  };
+}
+
+describe('Async Parallel Execution Timing', () => {
+  describe('parallel AI calls', () => {
+    test('multiple async AI calls run in parallel (timing)', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async let a = do "prompt1" m default
+        async let b = do "prompt2" m default
+        async let c = do "prompt3" m default
+        let result = a + " " + b + " " + c
+      `);
+
+      const delayMs = 100;
+      const aiProvider = createDelayedMockAI(delayMs, 'result');
+      const runtime = new Runtime(ast, aiProvider);
+
+      const startTime = Date.now();
+      await runtime.run();
+      const elapsed = Date.now() - startTime;
+
+      // If running in parallel, should take ~100ms (+ overhead)
+      // If running sequentially, would take ~300ms
+      // Allow some margin for overhead
+      expect(elapsed).toBeLessThan(250); // Much less than 300ms sequential time
+      expect(runtime.getValue('result')).toBe('result result result');
+    });
+
+    test('async calls with different responses', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async let a = do "get_A" m default
+        async let b = do "get_B" m default
+        async let c = do "get_C" m default
+        let result = a + b + c
+      `);
+
+      const delayMs = 50;
+      const aiProvider = createMultiResponseMockAI(delayMs, {
+        'get_A': 'A',
+        'get_B': 'B',
+        'get_C': 'C',
+      });
+      const runtime = new Runtime(ast, aiProvider);
+
+      const startTime = Date.now();
+      await runtime.run();
+      const elapsed = Date.now() - startTime;
+
+      // Parallel execution should be fast
+      expect(elapsed).toBeLessThan(150);
+      expect(runtime.getValue('result')).toBe('ABC');
+    });
+
+    test('six parallel calls with maxParallel=4 (throttling)', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async let a = do "1" m default
+        async let b = do "2" m default
+        async let c = do "3" m default
+        async let d = do "4" m default
+        async let e = do "5" m default
+        async let f = do "6" m default
+        let result = a + b + c + d + e + f
+      `);
+
+      const delayMs = 50;
+      const aiProvider = createDelayedMockAI(delayMs, 'x');
+      const runtime = new Runtime(ast, aiProvider, { maxParallel: 4 });
+
+      const startTime = Date.now();
+      await runtime.run();
+      const elapsed = Date.now() - startTime;
+
+      // With maxParallel=4 and 6 operations each taking 50ms:
+      // Wave 1: 4 parallel (50ms)
+      // Wave 2: 2 parallel (50ms)
+      // Total: ~100ms (+ overhead), definitely less than 6*50=300ms
+      expect(elapsed).toBeLessThan(200);
+      expect(runtime.getValue('result')).toBe('xxxxxx');
+    });
+  });
+
+  describe('execution order', () => {
+    test('sync operations before async are executed first', async () => {
+      // Track execution order
+      const executionOrder: string[] = [];
+
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        let sync1 = "first"
+        async let async1 = do "async_op" m default
+        let sync2 = "second"
+        let result = sync1 + " " + sync2
+      `);
+
+      const aiProvider: AIProvider = {
+        async execute(prompt: string): Promise<AIExecutionResult> {
+          executionOrder.push('ai_start');
+          await Bun.sleep(50);
+          executionOrder.push('ai_end');
+          return { value: 'async_result' };
+        },
+        async generateCode(): Promise<AIExecutionResult> {
+          return { value: '' };
+        },
+        async askUser(): Promise<string> {
+          return '';
+        },
+      };
+
+      const runtime = new Runtime(ast, aiProvider);
+      await runtime.run();
+
+      // Sync operations should complete before waiting for async
+      expect(runtime.getValue('sync1')).toBe('first');
+      expect(runtime.getValue('sync2')).toBe('second');
+      expect(runtime.getValue('result')).toBe('first second');
+    });
+
+    test('implicit await when using async variable', async () => {
+      const executionLog: string[] = [];
+
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async let x = do "get_x" m default
+        let y = x + "_used"
+      `);
+
+      const aiProvider: AIProvider = {
+        async execute(prompt: string): Promise<AIExecutionResult> {
+          executionLog.push('ai_called');
+          await Bun.sleep(50);
+          executionLog.push('ai_returned');
+          return { value: 'async_value' };
+        },
+        async generateCode(): Promise<AIExecutionResult> {
+          return { value: '' };
+        },
+        async askUser(): Promise<string> {
+          return '';
+        },
+      };
+
+      const runtime = new Runtime(ast, aiProvider);
+      await runtime.run();
+
+      // Variable y should have awaited x
+      expect(runtime.getValue('y')).toBe('async_value_used');
+      expect(executionLog).toContain('ai_returned');
+    });
+
+    test('destructuring waits for single AI call', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async let {name: text, age: number} = do "get_person" m default
+        let greeting = "Hello " + name
+      `);
+
+      const aiProvider: AIProvider = {
+        async execute(prompt: string): Promise<AIExecutionResult> {
+          await Bun.sleep(50);
+          return { value: { name: 'Alice', age: 30 } };
+        },
+        async generateCode(): Promise<AIExecutionResult> {
+          return { value: '' };
+        },
+        async askUser(): Promise<string> {
+          return '';
+        },
+      };
+
+      const runtime = new Runtime(ast, aiProvider);
+      await runtime.run();
+
+      expect(runtime.getValue('name')).toBe('Alice');
+      expect(runtime.getValue('age')).toBe(30);
+      expect(runtime.getValue('greeting')).toBe('Hello Alice');
+    });
+  });
+
+  describe('mixed async operations', () => {
+    test('async and sync declarations interleaved', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        let a = 1
+        async let b = do "get_b" m default
+        let c = 2
+        async let d = do "get_d" m default
+        let e = 3
+        let sum = a + c + e
+      `);
+
+      const delayMs = 50;
+      const aiProvider = createMultiResponseMockAI(delayMs, {
+        'get_b': 'B',
+        'get_d': 'D',
+      });
+
+      const runtime = new Runtime(ast, aiProvider);
+      const startTime = Date.now();
+      await runtime.run();
+      const elapsed = Date.now() - startTime;
+
+      // Sync operations should complete quickly
+      expect(runtime.getValue('sum')).toBe(6);
+      // Async operations should complete in parallel
+      expect(elapsed).toBeLessThan(150);
+    });
+
+    test('multiple async destructurings run in parallel', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async let {x: number, y: number} = do "get_coords" m default
+        async let {name: text, age: number} = do "get_person" m default
+        let result = name + " at " + x + "," + y
+      `);
+
+      const delayMs = 75;
+      const aiProvider: AIProvider = {
+        async execute(prompt: string): Promise<AIExecutionResult> {
+          await Bun.sleep(delayMs);
+          if (prompt.includes('coords')) {
+            return { value: { x: 10, y: 20 } };
+          }
+          return { value: { name: 'Bob', age: 25 } };
+        },
+        async generateCode(): Promise<AIExecutionResult> {
+          return { value: '' };
+        },
+        async askUser(): Promise<string> {
+          return '';
+        },
+      };
+
+      const runtime = new Runtime(ast, aiProvider);
+      const startTime = Date.now();
+      await runtime.run();
+      const elapsed = Date.now() - startTime;
+
+      // Both should run in parallel
+      expect(elapsed).toBeLessThan(200); // Less than 150ms * 2 = 300ms
+      expect(runtime.getValue('result')).toBe('Bob at 10,20');
+    });
+  });
+
+  describe('async const declarations', () => {
+    test('async const preserves const property', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async const x = do "get_value" m default
+        let y = x + "_suffix"
+      `);
+
+      const aiProvider = createDelayedMockAI(50, 'const_value');
+      const runtime = new Runtime(ast, aiProvider);
+      await runtime.run();
+
+      expect(runtime.getValue('x')).toBe('const_value');
+      expect(runtime.getValue('y')).toBe('const_value_suffix');
+
+      // Verify const property is preserved
+      const state = runtime.getState();
+      expect(state.callStack[0].locals['x'].isConst).toBe(true);
+    });
+
+    test('multiple async consts in parallel', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async const a = do "get_a" m default
+        async const b = do "get_b" m default
+        async const c = do "get_c" m default
+        let result = a + b + c
+      `);
+
+      const delayMs = 60;
+      const aiProvider = createMultiResponseMockAI(delayMs, {
+        'get_a': '1',
+        'get_b': '2',
+        'get_c': '3',
+      });
+
+      const runtime = new Runtime(ast, aiProvider);
+      const startTime = Date.now();
+      await runtime.run();
+      const elapsed = Date.now() - startTime;
+
+      expect(elapsed).toBeLessThan(150); // Parallel, not 180ms
+      expect(runtime.getValue('result')).toBe('123');
+    });
+  });
+
+  describe('private async declarations', () => {
+    test('async let private preserves private property', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async let private secret = do "get_secret" m default
+        let visible = "public"
+      `);
+
+      const aiProvider = createDelayedMockAI(50, 'secret_value');
+      const runtime = new Runtime(ast, aiProvider);
+      await runtime.run();
+
+      expect(runtime.getValue('secret')).toBe('secret_value');
+
+      // Verify private property is preserved
+      const state = runtime.getState();
+      expect(state.callStack[0].locals['secret'].isPrivate).toBe(true);
+    });
+  });
+
+  describe('standalone async (fire-and-forget)', () => {
+    test('standalone async do executes', async () => {
+      let aiCalled = false;
+
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async do "fire_and_forget" m default
+        let x = "done"
+      `);
+
+      const aiProvider: AIProvider = {
+        async execute(prompt: string): Promise<AIExecutionResult> {
+          aiCalled = true;
+          await Bun.sleep(50);
+          return { value: 'ignored' };
+        },
+        async generateCode(): Promise<AIExecutionResult> {
+          return { value: '' };
+        },
+        async askUser(): Promise<string> {
+          return '';
+        },
+      };
+
+      const runtime = new Runtime(ast, aiProvider);
+      await runtime.run();
+
+      expect(aiCalled).toBe(true);
+      expect(runtime.getValue('x')).toBe('done');
+    });
+  });
+
+  describe('error handling in parallel', () => {
+    test('error in one async does not block others', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async let good1 = do "good1" m default
+        async let bad = do "bad" m default
+        async let good2 = do "good2" m default
+      `);
+
+      let callCount = 0;
+      const aiProvider: AIProvider = {
+        async execute(prompt: string): Promise<AIExecutionResult> {
+          callCount++;
+          await Bun.sleep(30);
+          if (prompt.includes('bad')) {
+            throw new Error('Simulated failure');
+          }
+          return { value: 'success' };
+        },
+        async generateCode(): Promise<AIExecutionResult> {
+          return { value: '' };
+        },
+        async askUser(): Promise<string> {
+          return '';
+        },
+      };
+
+      const runtime = new Runtime(ast, aiProvider);
+      await runtime.run();
+
+      // All three should have been called
+      expect(callCount).toBe(3);
+
+      // Good ones should have results
+      expect(runtime.getValue('good1')).toBe('success');
+      expect(runtime.getValue('good2')).toBe('success');
+
+      // Bad one should have error in VibeValue
+      const state = runtime.getState();
+      expect(state.callStack[0].locals['bad'].err).toBe(true);  // err is now boolean
+      expect(state.callStack[0].locals['bad'].errDetails?.message).toBe('Simulated failure');
+    });
+  });
+
+  describe('async TS blocks', () => {
+    test('async TS block runs in parallel', async () => {
+      const ast = parse(`
+        async let x = ts() {
+          await Bun.sleep(50);
+          return 42;
+        }
+        async let y = ts() {
+          await Bun.sleep(50);
+          return 100;
+        }
+        let sum = x + y
+      `);
+
+      const aiProvider = createDelayedMockAI(50);
+      const runtime = new Runtime(ast, aiProvider);
+      const startTime = Date.now();
+      await runtime.run();
+      const elapsed = Date.now() - startTime;
+
+      // Two 50ms operations should complete in ~50ms if parallel, not 100ms
+      expect(elapsed).toBeLessThan(120);
+      expect(runtime.getValue('sum')).toBe(142);
+    });
+
+    test('multiple async TS blocks with max parallel', async () => {
+      const ast = parse(`
+        async let a = ts() { await Bun.sleep(40); return 1; }
+        async let b = ts() { await Bun.sleep(40); return 2; }
+        async let c = ts() { await Bun.sleep(40); return 3; }
+        async let d = ts() { await Bun.sleep(40); return 4; }
+        async let e = ts() { await Bun.sleep(40); return 5; }
+        let sum = a + b + c + d + e
+      `);
+
+      const aiProvider = createDelayedMockAI(50);
+      const runtime = new Runtime(ast, aiProvider, { maxParallel: 4 });
+      const startTime = Date.now();
+      await runtime.run();
+      const elapsed = Date.now() - startTime;
+
+      // With maxParallel=4: wave1 (4 ops, 40ms) + wave2 (1 op, 40ms) = ~80ms
+      expect(elapsed).toBeLessThan(150);
+      expect(runtime.getValue('sum')).toBe(15);
+    });
+
+    test('fire-and-forget async TS block schedules execution', async () => {
+      const ast = parse(`
+        async ts() {
+          await Bun.sleep(30);
+          return "ignored";
+        }
+        let x = "done"
+      `);
+
+      const aiProvider = createDelayedMockAI(50);
+      const runtime = new Runtime(ast, aiProvider);
+      await runtime.run();
+
+      // The program should complete and the TS block should have been awaited
+      // at block boundary (program end)
+      expect(runtime.getValue('x')).toBe('done');
+      // State should be completed (all async ops finished)
+      expect(runtime.getState().status).toBe('completed');
+    });
+  });
+
+  describe('mixed async types (AI + TS)', () => {
+    test('async AI and TS run in parallel', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async let aiResult = do "get_value" m default
+        async let tsResult = ts() {
+          await Bun.sleep(50);
+          return "ts_value";
+        }
+        let combined = aiResult + "_" + tsResult
+      `);
+
+      const delayMs = 50;
+      const aiProvider = createDelayedMockAI(delayMs, 'ai_value');
+      const runtime = new Runtime(ast, aiProvider);
+      const startTime = Date.now();
+      await runtime.run();
+      const elapsed = Date.now() - startTime;
+
+      // Both 50ms operations should run in parallel
+      expect(elapsed).toBeLessThan(120);
+      expect(runtime.getValue('combined')).toBe('ai_value_ts_value');
+    });
+
+    test('three different async types (AI, TS block, implicit await)', async () => {
+      const ast = parse(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        async let a = do "get_a" m default
+        async let b = ts() { await Bun.sleep(40); return "B"; }
+        async let c = do "get_c" m default
+        let result = a + b + c
+      `);
+
+      const aiProvider = createMultiResponseMockAI(40, {
+        'get_a': 'A',
+        'get_c': 'C',
+      });
+
+      const runtime = new Runtime(ast, aiProvider);
+      const startTime = Date.now();
+      await runtime.run();
+      const elapsed = Date.now() - startTime;
+
+      // All three should run in parallel (~40ms, not 120ms)
+      expect(elapsed).toBeLessThan(100);
+      expect(runtime.getValue('result')).toBe('ABC');
+    });
+  });
+});

package/src/runtime/test/basic1.test.ts

@@ -0,0 +1,154 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { Runtime, AIProvider } from '../index';
+
+// Mock AI provider for testing
+function createMockProvider(doResponse: string): AIProvider {
+  return {
+    async execute() {
+      return { value: doResponse };
+    },
+    async generateCode() {
+      return { value: `let result = "generated"` };
+    },
+    async askUser(): Promise<string> {
+      return 'user input';
+    },
+  };
+}
+
+describe('Runtime - Basic 1', () => {
+  test('vibe expression returns AI response into variable', async () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+let answer = vibe "what is 2 + 2?" myModel default
+answer
+`);
+    const provider = createMockProvider('4');
+    const runtime = new Runtime(ast, provider);
+    const result = await runtime.run();
+
+    expect(result).toBe('4');
+  });
+
+  test('getValue returns variable value after run', async () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+let answer = vibe "what is 2 + 2?" myModel default
+`);
+    const provider = createMockProvider('42');
+    const runtime = new Runtime(ast, provider);
+    await runtime.run();
+
+    expect(runtime.getValue('answer')).toBe('42');
+  });
+
+  test('json variable with object literal used in prompt', async () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+let userData: json = {name: "alice", role: "admin"}
+let result = vibe "Process this user" myModel default
+result
+`);
+    const provider = createMockProvider('User processed successfully');
+    const runtime = new Runtime(ast, provider);
+    const result = await runtime.run();
+
+    // Verify the json variable was created correctly
+    expect(runtime.getValue('userData')).toEqual({ name: 'alice', role: 'admin' });
+    expect(result).toBe('User processed successfully');
+  });
+
+  test('AI returns JSON string parsed into json variable', async () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+let response: json = vibe "Return user data as JSON" myModel default
+`);
+    // AI returns a JSON string
+    const provider = createMockProvider('{"id": 123, "name": "bob", "active": true}');
+    const runtime = new Runtime(ast, provider);
+    await runtime.run();
+
+    // The json type should auto-parse the string into an object
+    const response = runtime.getValue('response') as any;
+    expect(response).toEqual({ id: 123, name: 'bob', active: true });
+    expect(response.id).toBe(123);
+    expect(response.name).toBe('bob');
+  });
+
+  test('full program: create data, call AI, store json[] result', async () => {
+    const ast = parse(`
+model gpt = { name: "gpt-4", apiKey: "sk-test", url: "https://api.example.com" }
+
+let config: json = {
+  maxItems: "10",
+  filter: "active"
+}
+
+let users: json[] = vibe "fetch users with config" gpt default
+`);
+    // AI returns an array of users
+    const provider = createMockProvider('[{"name": "alice"}, {"name": "bob"}]');
+    const runtime = new Runtime(ast, provider);
+    await runtime.run();
+
+    // Verify config object
+    const config = runtime.getValue('config') as any;
+    expect(config.maxItems).toBe('10');
+    expect(config.filter).toBe('active');
+
+    // Verify parsed JSON array from AI
+    const users = runtime.getValue('users') as any;
+    expect(users).toHaveLength(2);
+    expect(users[0].name).toBe('alice');
+    expect(users[1].name).toBe('bob');
+  });
+
+  // Note: 'model config resolves variable references' test moved to model-config.test.ts
+
+  test('complex json structure matches expected exactly', async () => {
+    const ast = parse(`
+model api = { name: "gpt-4", apiKey: "key", url: "https://api.test.com" }
+
+let appState: json = {
+  user: {
+    id: "123",
+    profile: {
+      name: "alice",
+      settings: {
+        theme: "dark",
+        notifications: true
+      }
+    },
+    roles: ["admin", "editor"]
+  },
+  metadata: {
+    version: "1.0",
+    features: ["export", "import", "share"]
+  }
+}
+`);
+    const provider = createMockProvider('');
+    const runtime = new Runtime(ast, provider);
+    await runtime.run();
+
+    // Verify entire JSON structure matches expected
+    expect(runtime.getValue('appState')).toEqual({
+      user: {
+        id: '123',
+        profile: {
+          name: 'alice',
+          settings: {
+            theme: 'dark',
+            notifications: true,
+          },
+        },
+        roles: ['admin', 'editor'],
+      },
+      metadata: {
+        version: '1.0',
+        features: ['export', 'import', 'share'],
+      },
+    });
+  });
+});