@vibe-lang/runtime 0.2.5

package/src/runtime/test/member-methods.test.ts

@@ -0,0 +1,324 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { Runtime, AIProvider } from '../index';
+
+// Mock AI provider
+function createMockProvider(): AIProvider {
+  return {
+    async execute() {
+      return { value: '' };
+    },
+    async generateCode() {
+      return { value: '' };
+    },
+    async askUser(): Promise<string> {
+      return '';
+    },
+  };
+}
+
+describe('Array Methods - len()', () => {
+  test('len of empty array', async () => {
+    const ast = parse(`
+let arr = []
+let result = arr.len()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(0);
+  });
+
+  test('len of non-empty array', async () => {
+    const ast = parse(`
+let arr = [1, 2, 3, 4, 5]
+let result = arr.len()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(5);
+  });
+
+  test('len of array literal', async () => {
+    const ast = parse(`
+let result = [10, 20, 30].len()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(3);
+  });
+
+  test('len in expression', async () => {
+    const ast = parse(`
+let arr = [1, 2, 3]
+let result = arr.len() + 10
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(13);
+  });
+
+  test('len in condition', async () => {
+    const ast = parse(`
+let arr = [1, 2, 3]
+let result = "empty"
+if arr.len() > 0 {
+  result = "not empty"
+}
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe('not empty');
+  });
+});
+
+describe('Array Methods - push()', () => {
+  test('push to empty array', async () => {
+    const ast = parse(`
+let arr = []
+arr.push(42)
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('arr')).toEqual([42]);
+  });
+
+  test('push to non-empty array', async () => {
+    const ast = parse(`
+let arr = [1, 2, 3]
+arr.push(4)
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('arr')).toEqual([1, 2, 3, 4]);
+  });
+
+  test('push multiple times', async () => {
+    const ast = parse(`
+let arr = []
+arr.push(1)
+arr.push(2)
+arr.push(3)
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('arr')).toEqual([1, 2, 3]);
+  });
+
+  test('push returns the array for chaining', async () => {
+    const ast = parse(`
+let arr = []
+let result = arr.push(1).push(2).push(3)
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('arr')).toEqual([1, 2, 3]);
+    expect(runtime.getValue('result')).toEqual([1, 2, 3]);
+  });
+
+  test('push in loop', async () => {
+    const ast = parse(`
+let arr = []
+for i in 5 {
+  arr.push(i)
+}
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('arr')).toEqual([1, 2, 3, 4, 5]);
+  });
+});
+
+describe('Array Methods - pop()', () => {
+  test('pop from array', async () => {
+    const ast = parse(`
+let arr = [1, 2, 3]
+let result = arr.pop()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(3);
+    expect(runtime.getValue('arr')).toEqual([1, 2]);
+  });
+
+  test('pop multiple times', async () => {
+    const ast = parse(`
+let arr = [10, 20, 30]
+let a = arr.pop()
+let b = arr.pop()
+let c = arr.pop()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('a')).toBe(30);
+    expect(runtime.getValue('b')).toBe(20);
+    expect(runtime.getValue('c')).toBe(10);
+    expect(runtime.getValue('arr')).toEqual([]);
+  });
+
+  test('pop returns the removed element', async () => {
+    const ast = parse(`
+let arr = ["first", "second", "third"]
+let last = arr.pop()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('last')).toBe('third');
+  });
+});
+
+describe('String Methods - len()', () => {
+  test('len of empty string', async () => {
+    const ast = parse(`
+let s = ""
+let result = s.len()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(0);
+  });
+
+  test('len of non-empty string', async () => {
+    const ast = parse(`
+let s = "hello"
+let result = s.len()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(5);
+  });
+
+  test('len of string literal', async () => {
+    const ast = parse(`
+let result = "world".len()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(5);
+  });
+
+  test('len in comparison', async () => {
+    const ast = parse(`
+let name = "Alice"
+let result = name.len() == 5
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(true);
+  });
+});
+
+describe('Method Chaining', () => {
+  test('push chain then len', async () => {
+    const ast = parse(`
+let arr = []
+let result = arr.push(1).push(2).push(3).len()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(3);
+  });
+
+  test('method after index access', async () => {
+    const ast = parse(`
+let nested = [["a", "b", "c"], ["d", "e"]]
+let result = nested[0].len()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(3);
+  });
+
+  test('index after method', async () => {
+    const ast = parse(`
+let arr = []
+let result = arr.push(10).push(20).push(30)[1]
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(20);
+  });
+});
+
+describe('Methods with Other Features', () => {
+  test('method in while loop condition', async () => {
+    const ast = parse(`
+let arr = [1, 2, 3, 4, 5]
+let sum = 0
+while arr.len() > 0 {
+  sum = sum + arr.pop()
+}
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('sum')).toBe(15);
+    expect(runtime.getValue('arr')).toEqual([]);
+  });
+
+  test('method call passed to function', async () => {
+    const ast = parse(`
+function double(n: number): number {
+  return n * 2
+}
+let arr = [1, 2, 3]
+let result = double(arr.len())
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(6);
+  });
+
+  test('building arrays with push in function', async () => {
+    const ast = parse(`
+function buildArray(n: number): number[] {
+  let arr = []
+  for i in n {
+    arr.push(i * 10)
+  }
+  return arr
+}
+let result = buildArray(4)
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toEqual([10, 20, 30, 40]);
+  });
+});
+
+describe('Method Edge Cases', () => {
+  test('len of single element array', async () => {
+    const ast = parse(`
+let arr = [42]
+let result = arr.len()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('result')).toBe(1);
+  });
+
+  test('push and pop sequence', async () => {
+    const ast = parse(`
+let arr = [1]
+arr.push(2)
+let x = arr.pop()
+arr.push(3)
+let y = arr.pop()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    expect(runtime.getValue('x')).toBe(2);
+    expect(runtime.getValue('y')).toBe(3);
+    expect(runtime.getValue('arr')).toEqual([1]);
+  });
+
+  test('array method after slice', async () => {
+    const ast = parse(`
+let arr = [1, 2, 3, 4, 5]
+let sliced = arr[1:4]
+let result = sliced.len()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+    // Python-style: [1:4] = indices 1, 2, 3 = 3 elements
+    expect(runtime.getValue('result')).toBe(3);
+  });
+});

package/src/runtime/test/model-config.test.ts

@@ -0,0 +1,338 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { Runtime, type AIProvider } from '../index';
+
+describe('Runtime - Model Config Value Resolution', () => {
+  const mockProvider: AIProvider = {
+    execute: async (prompt: string) => ({ value: prompt }),
+    generateCode: async () => ({ value: '' }),
+    askUser: async () => '',
+  };
+
+  function createRuntime(code: string): Runtime {
+    const ast = parse(code);
+    return new Runtime(ast, mockProvider);
+  }
+
+  // ============================================================================
+  // Literal Values
+  // ============================================================================
+
+  test('model config with string literals', async () => {
+    const runtime = createRuntime(`
+model testModel = {
+  name: "gpt-4",
+  apiKey: "sk-test-key",
+  provider: "openai"
+}
+
+let modelInfo = ts(testModel) {
+  return { name: testModel.name, apiKey: testModel.apiKey, provider: testModel.provider };
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('modelInfo')).toEqual({
+      name: 'gpt-4',
+      apiKey: 'sk-test-key',
+      provider: 'openai',
+    });
+  });
+
+  test('model config with url literal', async () => {
+    const runtime = createRuntime(`
+model testModel = {
+  name: "custom-model",
+  apiKey: "key",
+  url: "https://api.example.com/v1"
+}
+
+let url = ts(testModel) {
+  return testModel.url;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('url')).toBe('https://api.example.com/v1');
+  });
+
+  // ============================================================================
+  // Variable References
+  // ============================================================================
+
+  test('model config with variable reference for apiKey', async () => {
+    const runtime = createRuntime(`
+const myKey = ts() {
+  return "resolved-api-key";
+}
+
+model testModel = {
+  name: "gpt-4",
+  apiKey: myKey,
+  provider: "openai"
+}
+
+let resolvedKey = ts(testModel) {
+  return testModel.apiKey;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('resolvedKey')).toBe('resolved-api-key');
+  });
+
+  test('model config with variable reference for name', async () => {
+    const runtime = createRuntime(`
+let modelName = "claude-3-opus"
+
+model testModel = {
+  name: modelName,
+  apiKey: "key",
+  provider: "anthropic"
+}
+
+let resolvedName = ts(testModel) {
+  return testModel.name;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('resolvedName')).toBe('claude-3-opus');
+  });
+
+  test('model config with variable reference for provider', async () => {
+    const runtime = createRuntime(`
+let myProvider = "anthropic"
+
+model testModel = {
+  name: "claude",
+  apiKey: "key",
+  provider: myProvider
+}
+
+let resolvedProvider = ts(testModel) {
+  return testModel.provider;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('resolvedProvider')).toBe('anthropic');
+  });
+
+  test('model config with multiple variable references', async () => {
+    const runtime = createRuntime(`
+let myName = "gpt-4"
+let myKey = "sk-secret"
+let myProvider = "openai"
+let myUrl = "https://custom.api.com"
+
+model testModel = {
+  name: myName,
+  apiKey: myKey,
+  provider: myProvider,
+  url: myUrl
+}
+
+let config = ts(testModel) {
+  return {
+    name: testModel.name,
+    apiKey: testModel.apiKey,
+    provider: testModel.provider,
+    url: testModel.url
+  };
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('config')).toEqual({
+      name: 'gpt-4',
+      apiKey: 'sk-secret',
+      provider: 'openai',
+      url: 'https://custom.api.com',
+    });
+  });
+
+  // ============================================================================
+  // Const vs Let Variables
+  // ============================================================================
+
+  test('model config with const variable reference', async () => {
+    const runtime = createRuntime(`
+const API_KEY = "const-api-key"
+
+model testModel = {
+  name: "test",
+  apiKey: API_KEY,
+  provider: "test"
+}
+
+let key = ts(testModel) {
+  return testModel.apiKey;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('key')).toBe('const-api-key');
+  });
+
+  test('model config with let variable reference', async () => {
+    const runtime = createRuntime(`
+let dynamicKey = "dynamic-key"
+
+model testModel = {
+  name: "test",
+  apiKey: dynamicKey,
+  provider: "test"
+}
+
+let key = ts(testModel) {
+  return testModel.apiKey;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('key')).toBe('dynamic-key');
+  });
+
+  // ============================================================================
+  // TS Block Results as Config Values
+  // ============================================================================
+
+  test('model config with ts block result', async () => {
+    const runtime = createRuntime(`
+const computedKey = ts() {
+  return "computed-" + "key";
+}
+
+model testModel = {
+  name: "test",
+  apiKey: computedKey,
+  provider: "test"
+}
+
+let key = ts(testModel) {
+  return testModel.apiKey;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('key')).toBe('computed-key');
+  });
+
+  // ============================================================================
+  // Edge Cases
+  // ============================================================================
+
+  test('model config with empty string', async () => {
+    const runtime = createRuntime(`
+model testModel = {
+  name: "",
+  apiKey: "key",
+  provider: "test"
+}
+
+let name = ts(testModel) {
+  return testModel.name;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('name')).toBe('');
+  });
+
+  test('model config with special characters in strings', async () => {
+    const runtime = createRuntime(`
+model testModel = {
+  name: "model-with-dashes",
+  apiKey: "sk_test_key_123",
+  url: "https://api.example.com/v1/chat?param=value"
+}
+
+let info = ts(testModel) {
+  return { name: testModel.name, apiKey: testModel.apiKey, url: testModel.url };
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('info')).toEqual({
+      name: 'model-with-dashes',
+      apiKey: 'sk_test_key_123',
+      url: 'https://api.example.com/v1/chat?param=value',
+    });
+  });
+
+  // ============================================================================
+  // CallExpression in Model Config - Currently Broken
+  // These tests FAIL with current implementation - they define expected behavior.
+  // ============================================================================
+
+  test('model config with env() function call', async () => {
+    process.env.TEST_MODEL_API_KEY = 'env-api-key-value';
+
+    // env() is auto-imported, no import needed
+    const runtime = createRuntime(`
+model testModel = {
+  name: "test",
+  apiKey: env("TEST_MODEL_API_KEY"),
+  provider: "test"
+}
+
+let key = ts(testModel) {
+  return testModel.apiKey;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('key')).toBe('env-api-key-value');
+
+    delete process.env.TEST_MODEL_API_KEY;
+  });
+
+  test('model config with inline ts block', async () => {
+    const runtime = createRuntime(`
+model testModel = {
+  name: "test",
+  apiKey: ts() { return "inline-key"; },
+  provider: "test"
+}
+
+let key = ts(testModel) {
+  return testModel.apiKey;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('key')).toBe('inline-key');
+  });
+
+  test('model config with vibe function call', async () => {
+    const runtime = createRuntime(`
+function getKey(): text {
+  return "function-key"
+}
+
+model testModel = {
+  name: "test",
+  apiKey: getKey(),
+  provider: "test"
+}
+
+let key = ts(testModel) {
+  return testModel.apiKey;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('key')).toBe('function-key');
+  });
+
+  // ============================================================================
+  // Workaround Tests - Assign to variable first, then use in model
+  // ============================================================================
+
+  test('workaround: ts block result assigned to variable then used in model', async () => {
+    const runtime = createRuntime(`
+const apiKey = ts() {
+  return process.env.TEST_KEY || "fallback-key";
+}
+
+model testModel = {
+  name: "test",
+  apiKey: apiKey,
+  provider: "test"
+}
+
+let key = ts(testModel) {
+  return testModel.apiKey;
+}
+`);
+    await runtime.run();
+    expect(runtime.getValue('key')).toBe('fallback-key');
+  });
+});