@vibe-lang/runtime 0.2.5

package/tests/integration/destructuring/destructuring.integration.test.ts

@@ -0,0 +1,92 @@
+// Destructuring Integration Tests
+// Tests destructuring declarations with const and let using Google Gemini 3
+
+import { describe, test, expect } from 'bun:test';
+import { Runtime, formatAIInteractions } from '../../../src/runtime';
+import { createRealAIProvider } from '../../../src/runtime/ai-provider';
+import { parse } from '../../../src/parser/parse';
+
+const GOOGLE_API_KEY = process.env.GOOGLE_API_KEY;
+
+const modelConfig = `
+model testModel = {
+  name: "gemini-3-flash-preview",
+  apiKey: "${GOOGLE_API_KEY}",
+  provider: "google"
+}
+`;
+
+async function runVibe(vibeCode: string, logAi = true): Promise<Runtime> {
+  const program = parse(modelConfig + vibeCode);
+  const runtime = new Runtime(
+    program,
+    createRealAIProvider(() => runtime.getState()),
+    { logAiInteractions: logAi }
+  );
+  await runtime.run();
+
+  if (logAi) {
+    const interactions = runtime.getAIInteractions();
+    console.log('\n' + formatAIInteractions(interactions));
+  }
+
+  return runtime;
+}
+
+describe.skipIf(!GOOGLE_API_KEY)('Google Gemini 3 - Destructuring Declarations', () => {
+  test('const destructuring with multiple fields', async () => {
+    const runtime = await runVibe(`
+const {name: text, age: number} = do "Return a person named Alice who is 25 years old" testModel default
+`);
+    expect(runtime.getValue('name')).toBe('Alice');
+    expect(runtime.getValue('age')).toBe(25);
+  }, 30000);
+
+  test('let destructuring with multiple fields', async () => {
+    const runtime = await runVibe(`
+let {city: text, population: number} = do "Return a city named Tokyo with population 14000000" testModel default
+`);
+    expect(runtime.getValue('city')).toBe('Tokyo');
+    expect(runtime.getValue('population')).toBe(14000000);
+  }, 30000);
+
+  test('const destructuring with boolean field', async () => {
+    const runtime = await runVibe(`
+const {valid: boolean, message: text} = do "Return valid as true and message as OK" testModel default
+`);
+    expect(runtime.getValue('valid')).toBe(true);
+    expect(runtime.getValue('message')).toBe('OK');
+  }, 30000);
+
+  test('let destructuring with array fields', async () => {
+    const runtime = await runVibe(`
+let {colors: text[], counts: number[]} = do "Return colors as [red, green, blue] and counts as [1, 2, 3]" testModel default
+`);
+    const colors = runtime.getValue('colors') as string[];
+    const counts = runtime.getValue('counts') as number[];
+    expect(Array.isArray(colors)).toBe(true);
+    expect(colors).toEqual(['red', 'green', 'blue']);
+    expect(Array.isArray(counts)).toBe(true);
+    expect(counts).toEqual([1, 2, 3]);
+  }, 30000);
+
+  test('const destructuring with json field', async () => {
+    const runtime = await runVibe(`
+const {user: json, active: boolean} = do "Return user as an object with name Alice and role admin, and active as true" testModel default
+`);
+    const user = runtime.getValue('user') as Record<string, unknown>;
+    expect(typeof user).toBe('object');
+    expect(user.name).toBe('Alice');
+    expect(user.role).toBe('admin');
+    expect(runtime.getValue('active')).toBe(true);
+  }, 30000);
+
+  test('destructuring with three fields', async () => {
+    const runtime = await runVibe(`
+const {x: number, y: number, z: number} = do "Return x as 10, y as 20, z as 30" testModel default
+`);
+    expect(runtime.getValue('x')).toBe(10);
+    expect(runtime.getValue('y')).toBe(20);
+    expect(runtime.getValue('z')).toBe(30);
+  }, 30000);
+});

package/tests/integration/hello-world-translator/hello-world-translator.integration.test.ts

@@ -0,0 +1,61 @@
+// Multi-language Hello World Translator Integration Test
+// Tests optional model/context syntax and lastUsedModel feature
+
+import { describe, test, expect } from 'bun:test';
+import { Runtime, formatAIInteractions } from '../../../src/runtime';
+import { createRealAIProvider } from '../../../src/runtime/ai-provider';
+import { parse } from '../../../src/parser/parse';
+
+const GOOGLE_API_KEY = process.env.GOOGLE_API_KEY;
+
+async function runVibe(code: string, logAi = true): Promise<Runtime> {
+  const program = parse(code);
+  const runtime = new Runtime(
+    program,
+    createRealAIProvider(() => runtime.getState()),
+    { logAiInteractions: logAi }
+  );
+  await runtime.run();
+
+  if (logAi) {
+    const interactions = runtime.getAIInteractions();
+    console.log('\n' + formatAIInteractions(interactions));
+  }
+
+  return runtime;
+}
+
+describe.skipIf(!GOOGLE_API_KEY)('Hello World Translator', () => {
+
+  test('translate Hello World to multiple languages', async () => {
+    // print() and env() are auto-imported core functions - no import needed
+    const code = `
+model translator = {
+  name: "gemini-3-flash-preview",
+  provider: "google",
+  apiKey: env("GOOGLE_API_KEY")
+}
+
+// First call establishes lastUsedModel
+let languages: text[] = do "List the major human languages(max 10) as a JSON array of strings."
+
+// Loop uses lastUsedModel (translator) since no model specified
+for language in languages {
+  let translated = do "Translate 'Hello World' into {language}. Return only the translation, nothing else."
+  print(translated)
+}
+`;
+
+    const runtime = await runVibe(code);
+
+    // Check that languages array was populated
+    const languages = runtime.getValue('languages') as string[];
+    expect(Array.isArray(languages)).toBe(true);
+    expect(languages.length).toBeGreaterThanOrEqual(1);
+
+    // The loop should have run and printed translations
+    expect(runtime.getState().status).toBe('completed');
+  }, 60000);
+
+
+});

package/tests/integration/line-annotator/context-modes.integration.test.ts

@@ -0,0 +1,261 @@
+// Context Modes Integration Test
+// Tests that forget mode properly cleans up inner loop context
+
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { Runtime, formatAIInteractions } from '../../../src/runtime';
+import { createRealAIProvider } from '../../../src/runtime/ai-provider';
+import { parse } from '../../../src/parser/parse';
+import { buildLocalContext, formatContextForAI } from '../../../src/runtime/context';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+const shouldRun = !!ANTHROPIC_API_KEY;
+
+// Test directory setup
+const TEST_WORKSPACE = path.join(__dirname, '.test-workspace-context');
+
+// Test file contents
+const SAMPLE_FILES = {
+  'file1.txt': `Line one
+Line two
+Line three`,
+
+  'file2.txt': `Alpha
+Beta
+Gamma`,
+};
+
+// Expected line lengths for verification
+const EXPECTED_LENGTHS: Record<string, number[]> = {
+  'file1.txt': [8, 8, 10],
+  'file2.txt': [5, 4, 5],
+};
+
+// Function to generate Vibe program with configurable context mode
+function createVibeProgram(innerLoopMode: 'forget' | 'verbose' | ''): string {
+  const modeKeyword = innerLoopMode ? ` ${innerLoopMode}` : '';
+
+  return `
+import { glob, readFile, writeFile } from "system/tools"
+
+model analyzer = {
+  name: "claude-haiku-4-5",
+  apiKey: "${ANTHROPIC_API_KEY}",
+  url: "https://api.anthropic.com",
+  provider: "anthropic",
+  tools: [glob, readFile, writeFile]
+}
+
+// Find all .txt files
+let files: text[] = vibe "Find all .txt files in the current directory. Return just the filenames as an array." analyzer default
+
+// Process each file
+for file in files {
+  // Read the file
+  let content: text = vibe "Use the readFile tool to read '{file}'. Return the exact file contents with no formatting, no markdown, no code blocks - just the raw text." analyzer default
+
+  // Split content into lines using inline TS
+  let lines: text[] = ts(content) { return content.split('\\n'); }
+
+  // Process each line - TS calculates length
+  let annotatedLines: number[] = []
+  for line in lines {
+    let annotated: number = ts(line) { return (line ?? '').length }
+    annotatedLines.push(annotated)
+  }${modeKeyword}
+
+  // Write annotated file
+  vibe "update the file '{file}' with the annotated lines, so each line ends with its length in brackets like [5]" analyzer default
+}
+
+"done"
+`;
+}
+
+describe.skipIf(!shouldRun)('Context Modes Integration', () => {
+  beforeAll(() => {
+    // Create test workspace and sample files
+    fs.mkdirSync(TEST_WORKSPACE, { recursive: true });
+    for (const [filename, content] of Object.entries(SAMPLE_FILES)) {
+      fs.writeFileSync(path.join(TEST_WORKSPACE, filename), content);
+    }
+  });
+
+  afterAll(() => {
+    // Clean up test workspace
+    if (fs.existsSync(TEST_WORKSPACE)) {
+      fs.rmSync(TEST_WORKSPACE, { recursive: true });
+    }
+  });
+
+  test(
+    'forget mode cleans up inner loop iterations from context',
+    async () => {
+      // Run with forget mode on inner loop
+      const program = parse(createVibeProgram('forget'));
+      const runtime = new Runtime(program, createRealAIProvider(() => runtime.getState()), {
+        logAiInteractions: true,
+        rootDir: TEST_WORKSPACE,
+      });
+
+      await runtime.run();
+
+      const state = runtime.getState();
+      console.log('\n=== FORGET MODE ===');
+      console.log(formatAIInteractions(state.aiInteractions));
+
+      // Get the final context
+      const context = buildLocalContext(state);
+      const formatted = formatContextForAI(context);
+      console.log('\n=== FINAL CONTEXT ===');
+      console.log(formatted.text);
+
+      // Verify files were processed correctly
+      for (const [filename, expectedLengths] of Object.entries(EXPECTED_LENGTHS)) {
+        const filePath = path.join(TEST_WORKSPACE, filename);
+        const content = fs.readFileSync(filePath, 'utf-8').trim();
+        const lines = content.split('\n');
+
+        console.log(`\n--- ${filename} ---`);
+        console.log(content);
+
+        expect(lines.length).toBe(expectedLengths.length);
+
+        for (let i = 0; i < lines.length; i++) {
+          const match = lines[i].match(/\[(\d+)\]$/);
+          expect(match).not.toBeNull();
+          if (match) {
+            expect(parseInt(match[1], 10)).toBe(expectedLengths[i]);
+          }
+        }
+      }
+
+      // KEY ASSERTION: With forget mode, the inner loop iterations should NOT be in context
+      // The context should NOT contain individual "line" variable assignments from the inner loop
+      const contextText = formatted.text;
+
+      // Count how many times "- line (text):" appears - should be minimal with forget
+      const lineVarMatches = contextText.match(/- line \(text\):/g) || [];
+      console.log(`\nLine variable occurrences in context: ${lineVarMatches.length}`);
+
+      // With forget, we should NOT see accumulated line iterations
+      // Each file has 3 lines, 2 files = 6 iterations total
+      // With forget, none of these should persist in final context
+      expect(lineVarMatches.length).toBe(0);
+
+      // Also verify the annotatedLines array IS present (the final result)
+      expect(contextText).toContain('annotatedLines');
+    },
+    300000
+  );
+
+  test(
+    'verbose mode (default) keeps all inner loop iterations in context',
+    async () => {
+      // Reset test files
+      for (const [filename, content] of Object.entries(SAMPLE_FILES)) {
+        fs.writeFileSync(path.join(TEST_WORKSPACE, filename), content);
+      }
+
+      // Run with verbose mode (explicit) on inner loop
+      const program = parse(createVibeProgram('verbose'));
+      const runtime = new Runtime(program, createRealAIProvider(() => runtime.getState()), {
+        logAiInteractions: true,
+        rootDir: TEST_WORKSPACE,
+      });
+
+      await runtime.run();
+
+      const state = runtime.getState();
+      console.log('\n=== VERBOSE MODE ===');
+      console.log(formatAIInteractions(state.aiInteractions));
+
+      // Get the final context
+      const context = buildLocalContext(state);
+      const formatted = formatContextForAI(context);
+      console.log('\n=== FINAL CONTEXT ===');
+      console.log(formatted.text);
+
+      // Verify files were processed correctly
+      for (const [filename, expectedLengths] of Object.entries(EXPECTED_LENGTHS)) {
+        const filePath = path.join(TEST_WORKSPACE, filename);
+        const content = fs.readFileSync(filePath, 'utf-8').trim();
+        const lines = content.split('\n');
+
+        expect(lines.length).toBe(expectedLengths.length);
+
+        for (let i = 0; i < lines.length; i++) {
+          const match = lines[i].match(/\[(\d+)\]$/);
+          expect(match).not.toBeNull();
+          if (match) {
+            expect(parseInt(match[1], 10)).toBe(expectedLengths[i]);
+          }
+        }
+      }
+
+      // KEY ASSERTION: With verbose mode, the inner loop iterations SHOULD be in context
+      const contextText = formatted.text;
+
+      // Count how many times "- line (text):" appears
+      const lineVarMatches = contextText.match(/- line \(text\):/g) || [];
+      console.log(`\nLine variable occurrences in context: ${lineVarMatches.length}`);
+
+      // With verbose, we SHOULD see all line iterations
+      // Each file has 3 lines, 2 files = 6 iterations total
+      // But due to outer loop verbose behavior, we see all from both files
+      expect(lineVarMatches.length).toBeGreaterThan(0);
+    },
+    300000
+  );
+
+  test(
+    'compare token usage between forget and verbose modes',
+    async () => {
+      // Reset test files
+      for (const [filename, content] of Object.entries(SAMPLE_FILES)) {
+        fs.writeFileSync(path.join(TEST_WORKSPACE, filename), content);
+      }
+
+      // Run forget mode
+      const forgetProgram = parse(createVibeProgram('forget'));
+      const forgetRuntime = new Runtime(forgetProgram, createRealAIProvider(() => forgetRuntime.getState()), {
+        logAiInteractions: true,
+        rootDir: TEST_WORKSPACE,
+      });
+      await forgetRuntime.run();
+      const forgetState = forgetRuntime.getState();
+
+      // Calculate total tokens for forget mode
+      const forgetTokens = forgetState.aiInteractions?.reduce((sum, i) => sum + (i.usage?.inputTokens ?? 0), 0) ?? 0;
+
+      // Reset test files
+      for (const [filename, content] of Object.entries(SAMPLE_FILES)) {
+        fs.writeFileSync(path.join(TEST_WORKSPACE, filename), content);
+      }
+
+      // Run verbose mode
+      const verboseProgram = parse(createVibeProgram('verbose'));
+      const verboseRuntime = new Runtime(verboseProgram, createRealAIProvider(() => verboseRuntime.getState()), {
+        logAiInteractions: true,
+        rootDir: TEST_WORKSPACE,
+      });
+      await verboseRuntime.run();
+      const verboseState = verboseRuntime.getState();
+
+      // Calculate total tokens for verbose mode
+      const verboseTokens = verboseState.aiInteractions?.reduce((sum, i) => sum + (i.usage?.inputTokens ?? 0), 0) ?? 0;
+
+      console.log('\n=== TOKEN COMPARISON ===');
+      console.log(`Forget mode total input tokens: ${forgetTokens}`);
+      console.log(`Verbose mode total input tokens: ${verboseTokens}`);
+      console.log(`Difference: ${verboseTokens - forgetTokens} tokens`);
+      console.log(`Forget mode saves: ${((1 - forgetTokens / verboseTokens) * 100).toFixed(1)}%`);
+
+      // Forget mode should use fewer tokens (less context accumulation)
+      // Note: This might not always be true for small examples, but for larger ones it should be
+      console.log('\nBoth modes completed successfully!');
+    },
+    600000 // 10 minute timeout for both runs
+  );
+});

package/tests/integration/line-annotator/line-annotator.integration.test.ts

@@ -0,0 +1,148 @@
+// Line Annotator Integration Test
+// Tests tool calling, Vibe loops, and TS functions working together
+
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { Runtime, formatAIInteractions } from '../../../src/runtime';
+import { createRealAIProvider } from '../../../src/runtime/ai-provider';
+import { parse } from '../../../src/parser/parse';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+const shouldRun = !!ANTHROPIC_API_KEY;
+
+// Test directory setup
+const TEST_WORKSPACE = path.join(__dirname, '.test-workspace');
+
+// Test file contents (simplified for initial testing)
+const SAMPLE_FILES = {
+  'sample1.txt': `Hello world
+Short
+End`,
+
+  'sample2.txt': `Apple
+Banana
+Cherry`,
+};
+
+// Expected line lengths for verification
+const EXPECTED_LENGTHS: Record<string, number[]> = {
+  'sample1.txt': [11, 5, 3],
+  'sample2.txt': [5, 6, 6],
+};
+
+// Vibe program that processes files
+const VIBE_PROGRAM = `
+import { glob, readFile, writeFile } from "system/tools"
+
+model analyzer = {
+  name: "claude-haiku-4-5",
+  apiKey: "${ANTHROPIC_API_KEY}",
+  url: "https://api.anthropic.com",
+  provider: "anthropic",
+  tools: [glob, readFile, writeFile]
+}
+
+// Find all .txt files
+let files: text[] = vibe "Find all .txt files in the current directory. Return just the filenames as an array." analyzer default
+
+// Process each file
+for file in files {
+  // Read the file
+  let content: text = vibe "Use the readFile tool to read '{file}'. Return the exact file contents with no formatting, no markdown, no code blocks - just the raw text." analyzer default
+
+  // Split content into lines using inline TS
+  let lines: text[] = ts(content) { return content.split('\\n'); }
+
+  // Process each line - TS calculates length and annotates
+  let annotatedLines: number[] = []
+  for line in lines {
+    let annotated: number = ts(line) {return (line ?? '').length }
+    annotatedLines.push(annotated)
+  }
+  vibe "update the file '{file}' with the annotated lines, so each line ends with its length in brackets like [5]" analyzer default
+}
+
+"done"
+`;
+
+describe.skipIf(!shouldRun)('Line Annotator Integration', () => {
+  beforeAll(() => {
+    // Create test workspace and sample files
+    fs.mkdirSync(TEST_WORKSPACE, { recursive: true });
+    for (const [filename, content] of Object.entries(SAMPLE_FILES)) {
+      fs.writeFileSync(path.join(TEST_WORKSPACE, filename), content);
+    }
+  });
+
+  afterAll(() => {
+    // Clean up test workspace
+    if (fs.existsSync(TEST_WORKSPACE)) {
+      fs.rmSync(TEST_WORKSPACE, { recursive: true });
+    }
+  });
+
+  test(
+    'AI annotates each line with its length using nested loops',
+    async () => {
+      // Verify initial files exist
+      for (const filename of Object.keys(SAMPLE_FILES)) {
+        expect(fs.existsSync(path.join(TEST_WORKSPACE, filename))).toBe(true);
+      }
+
+      // Run the Vibe program
+      const program = parse(VIBE_PROGRAM);
+      const runtime = new Runtime(program, createRealAIProvider(() => runtime.getState()), {
+        logAiInteractions: true,
+        rootDir: TEST_WORKSPACE,
+      });
+
+      await runtime.run();
+
+      // Log AI interactions
+      const state = runtime.getState();
+      console.log('\n' + formatAIInteractions(state.aiInteractions));
+
+      // Verify tool calls were made
+      const hasToolCalls = state.callStack.some((frame) =>
+        frame.orderedEntries.some(
+          (entry) => entry.kind === 'prompt' && entry.toolCalls && entry.toolCalls.length > 0
+        )
+      );
+      console.log(`\nTool calls made: ${hasToolCalls}`);
+      expect(hasToolCalls).toBe(true);
+
+      // Verify each file was annotated correctly
+      for (const [filename, expectedLengths] of Object.entries(EXPECTED_LENGTHS)) {
+        const filePath = path.join(TEST_WORKSPACE, filename);
+        const content = fs.readFileSync(filePath, 'utf-8').trim();
+        const lines = content.split('\n');
+
+        console.log(`\n--- ${filename} ---`);
+        console.log(content);
+
+        // Check line count matches
+        expect(lines.length).toBe(expectedLengths.length);
+
+        // Check each line ends with correct length annotation
+        for (let i = 0; i < lines.length; i++) {
+          const line = lines[i];
+          const expectedLength = expectedLengths[i];
+
+          // Line should end with [N] where N is the expected length
+          const match = line.match(/\[(\d+)\]$/);
+          expect(match).not.toBeNull();
+
+          if (match) {
+            const actualLength = parseInt(match[1], 10);
+            expect(actualLength).toBe(expectedLength);
+          }
+        }
+      }
+
+      // Program completed successfully
+      console.log('\nAll files annotated successfully!');
+    },
+    300000
+  ); // 5 minute timeout for many AI calls
+});

package/tests/integration/multi-feature/cumulative-sum.integration.test.ts

@@ -0,0 +1,75 @@
+// Cumulative Sum Integration Test
+// Simple test: AI adds numbers one at a time in a loop
+
+import { describe, test, expect } from 'bun:test';
+import { Runtime, formatAIInteractions } from '../../../src/runtime';
+import { createRealAIProvider } from '../../../src/runtime/ai-provider';
+import { parse } from '../../../src/parser/parse';
+
+const ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+const shouldRun = !!ANTHROPIC_API_KEY;
+
+// Generate random integers for the test
+const numbers = Array.from({ length: 5 }, () => Math.floor(Math.random() * 20) - 5);
+const bonusNumber = Math.floor(Math.random() * 10) + 1;
+const expectedSum = numbers.reduce((a, b) => a + b, 0) + bonusNumber;
+
+const VIBE_PROGRAM = `
+model calc = {
+  name: "claude-haiku-4-5",
+  apiKey: "${ANTHROPIC_API_KEY}",
+  url: "https://api.anthropic.com",
+  provider: "anthropic"
+}
+
+let numbers: number[] = [${numbers.join(', ')}]
+let sum: number = 0
+
+for n in numbers {
+  let result: number = vibe "Add n to sum. Return only the number." calc default
+  sum = result
+}
+
+let bonus: number = ${bonusNumber}
+let final: number = vibe "Add bonus to sum. Return only the number." calc default
+`;
+
+async function runTest(logAi = true): Promise<Runtime> {
+  const program = parse(VIBE_PROGRAM);
+  const runtime = new Runtime(
+    program,
+    createRealAIProvider(() => runtime.getState()),
+    { logAiInteractions: logAi }
+  );
+  await runtime.run();
+
+  if (logAi) {
+    console.log('\n' + formatAIInteractions(runtime.getAIInteractions()));
+  }
+
+  return runtime;
+}
+
+describe.skipIf(!shouldRun)('Cumulative Sum Integration', () => {
+  test('AI adds numbers correctly in a loop', async () => {
+    console.log(`\nTest numbers: [${numbers.join(', ')}] + bonus ${bonusNumber}`);
+    console.log(`Expected sum: ${expectedSum}`);
+
+    const runtime = await runTest();
+
+    const finalSum = runtime.getValue('final') as number;
+    console.log(`AI computed sum: ${finalSum}`);
+
+    // AI should compute the correct sum
+    expect(finalSum).toBe(expectedSum);
+
+    // Verify we made the right number of AI calls (loop + bonus)
+    const interactions = runtime.getAIInteractions();
+    expect(interactions.length).toBe(numbers.length + 1);
+
+    // Each interaction should be a number response
+    for (const interaction of interactions) {
+      expect(interaction.targetType).toBe('number');
+    }
+  }, 120000);
+});