@vibe-lang/runtime 0.2.8 → 0.2.10

package/src/runtime/test/throw.test.ts

@@ -0,0 +1,220 @@
+// Tests for throw statement - throw "message" returns immediately with error value
+
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { Runtime } from '../index';
+import type { AIProvider, AIResponse } from '../types';
+import { isVibeValue } from '../types';
+
+// Mock provider for tests that don't need AI
+function createMockProvider(): AIProvider {
+  return {
+    async chat(): Promise<AIResponse> {
+      return { content: 'mock response', toolCalls: [] };
+    },
+  };
+}
+
+describe('Throw Statement', () => {
+  test('throw with string literal creates error value', async () => {
+    const ast = parse(`
+function fail(): text {
+  throw "Something went wrong"
+  return "never reached"
+}
+
+let result = fail()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+
+    const result = runtime.getRawValue('result');
+    expect(isVibeValue(result)).toBe(true);
+    if (isVibeValue(result)) {
+      expect(result.err).toBe(true);
+      expect(result.errDetails?.message).toBe('Something went wrong');
+    }
+  });
+
+  test('throw returns immediately from function', async () => {
+    const ast = parse(`
+let sideEffect = 0
+
+function testThrow(): number {
+  sideEffect = 1
+  throw "error"
+  sideEffect = 2
+  return 42
+}
+
+let result = testThrow()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+
+    // Side effect should only be 1 (before throw)
+    expect(runtime.getValue('sideEffect')).toBe(1);
+
+    const result = runtime.getRawValue('result');
+    expect(isVibeValue(result)).toBe(true);
+    if (isVibeValue(result)) {
+      expect(result.err).toBe(true);
+    }
+  });
+
+  test('throw with expression evaluates message', async () => {
+    const ast = parse(`
+function divide(a: number, b: number): number {
+  if b == 0 {
+    throw "Cannot divide " + a + " by zero"
+  }
+  return a / b
+}
+
+let result = divide(10, 0)
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+
+    const result = runtime.getRawValue('result');
+    expect(isVibeValue(result)).toBe(true);
+    if (isVibeValue(result)) {
+      expect(result.err).toBe(true);
+      expect(result.errDetails?.message).toBe('Cannot divide 10 by zero');
+    }
+  });
+
+  test('successful function call returns normal value', async () => {
+    const ast = parse(`
+function divide(a: number, b: number): number {
+  if b == 0 {
+    throw "Division by zero"
+  }
+  return a / b
+}
+
+let result = divide(10, 2)
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+
+    const result = runtime.getRawValue('result');
+    expect(isVibeValue(result)).toBe(true);
+    if (isVibeValue(result)) {
+      expect(result.err).toBe(false);
+      expect(result.value).toBe(5);
+    }
+  });
+
+  test('error propagates through expressions', async () => {
+    const ast = parse(`
+function fail(): number {
+  throw "error"
+}
+
+let a = fail()
+let b = a + 10
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+
+    const a = runtime.getRawValue('a');
+    const b = runtime.getRawValue('b');
+
+    expect(isVibeValue(a)).toBe(true);
+    expect(isVibeValue(b)).toBe(true);
+
+    if (isVibeValue(a) && isVibeValue(b)) {
+      expect(a.err).toBe(true);
+      expect(b.err).toBe(true);  // Error propagates
+      expect(b.errDetails?.message).toBe('error');
+    }
+  });
+
+  test('caller can check for error with .err', async () => {
+    const ast = parse(`
+function mayFail(shouldFail: boolean): text {
+  if shouldFail {
+    throw "Failed!"
+  }
+  return "Success"
+}
+
+let result1 = mayFail(true)
+let hasError1 = result1.err
+
+let result2 = mayFail(false)
+let hasError2 = result2.err
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+
+    expect(runtime.getValue('hasError1')).toBe(true);
+    expect(runtime.getValue('hasError2')).toBe(false);
+  });
+
+  test('throw at top level completes with error', async () => {
+    const ast = parse(`
+let x = 1
+throw "Top level error"
+let y = 2
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+
+    expect(runtime.getValue('x')).toBe(1);
+    // y should not be set because throw exits
+    expect(runtime.getValue('y')).toBeUndefined();
+
+    // lastResult should be the error
+    const lastResult = runtime.getState().lastResult;
+    expect(isVibeValue(lastResult)).toBe(true);
+    if (isVibeValue(lastResult)) {
+      expect(lastResult.err).toBe(true);
+      expect(lastResult.errDetails?.message).toBe('Top level error');
+    }
+  });
+
+  test('throw in nested function unwinds correctly', async () => {
+    const ast = parse(`
+function inner(): number {
+  throw "inner error"
+}
+
+function outer(): number {
+  let x = inner()
+  return x + 1
+}
+
+let result = outer()
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+
+    const result = runtime.getRawValue('result');
+    expect(isVibeValue(result)).toBe(true);
+    if (isVibeValue(result)) {
+      expect(result.err).toBe(true);
+      expect(result.errDetails?.message).toBe('inner error');
+    }
+  });
+
+  test('throw with variable message', async () => {
+    const ast = parse(`
+function failWith(msg: text): text {
+  throw msg
+}
+
+let result = failWith("custom error message")
+`);
+    const runtime = new Runtime(ast, createMockProvider());
+    await runtime.run();
+
+    const result = runtime.getRawValue('result');
+    expect(isVibeValue(result)).toBe(true);
+    if (isVibeValue(result)) {
+      expect(result.err).toBe(true);
+      expect(result.errDetails?.message).toBe('custom error message');
+    }
+  });
+});

package/src/runtime/test/tool-execution.test.ts

@@ -177,9 +177,9 @@ let x = 1
     expect(runtime.getValue('x')).toBe(1);
   });
 
-  test('uuid function works when imported from system', async () => {
+  test('uuid function works when imported from system/utils', async () => {
     const ast = parse(`
-import { uuid } from "system"
+import { uuid } from "system/utils"
 let id = uuid()
 `);
     const runtime = new Runtime(ast, createMockProvider());
@@ -190,41 +190,41 @@ let id = uuid()
   });
 
   // ============================================================================
-  // Tools cannot be called directly - only used by AI models
+  // Utility functions can be called directly from system/utils
   // ============================================================================
 
-  test('tools cannot be called directly from vibe scripts', async () => {
+  test('now can be called directly from system/utils', async () => {
     const ast = parse(`
-import { now } from "system/tools"
+import { now } from "system/utils"
 let timestamp = now()
 `);
     const runtime = new Runtime(ast, createMockProvider());
-    await expect(runtime.run()).rejects.toThrow(
-      "Cannot call tool 'now' directly"
-    );
+    await runtime.run();
+    const timestamp = runtime.getValue('timestamp');
+    expect(typeof timestamp).toBe('number');
+    expect(timestamp).toBeGreaterThan(0);
   });
 
-  test('jsonParse tool cannot be called directly', async () => {
+  test('jsonParse can be called directly from system/utils', async () => {
     const ast = parse(`
-import { jsonParse } from "system/tools"
+import { jsonParse } from "system/utils"
 let parsed = jsonParse('{"key": "value"}')
+let val = ts(parsed) { return parsed.key }
 `);
     const runtime = new Runtime(ast, createMockProvider());
-    await expect(runtime.run()).rejects.toThrow(
-      "Cannot call tool 'jsonParse' directly"
-    );
+    await runtime.run();
+    expect(runtime.getValue('val')).toBe('value');
   });
 
-  test('jsonStringify tool cannot be called directly', async () => {
+  test('jsonStringify can be called directly from system/utils', async () => {
     const ast = parse(`
-import { jsonStringify } from "system/tools"
+import { jsonStringify } from "system/utils"
 let obj:json = {name: "test"}
 let str = jsonStringify(obj)
 `);
     const runtime = new Runtime(ast, createMockProvider());
-    await expect(runtime.run()).rejects.toThrow(
-      "Cannot call tool 'jsonStringify' directly"
-    );
+    await runtime.run();
+    expect(runtime.getValue('str')).toBe('{"name":"test"}');
   });
 
   test('allTools array can be imported from system/tools', async () => {
@@ -235,7 +235,7 @@ let toolCount = ts(allTools) { return allTools.length }
     const runtime = new Runtime(ast, createMockProvider());
     await runtime.run();
     const toolCount = runtime.getValue('toolCount');
-    expect(toolCount).toBe(19); // File, search, directory, utility, and system tools for AI
+    expect(toolCount).toBe(13); // File, search, directory, and system tools for AI
   });
 });
 
@@ -332,9 +332,9 @@ let x = 1
     const runtime = new Runtime(ast, createMockProvider());
     await runtime.run();
 
-    // Verify model has all 19 tools
+    // Verify model has all 13 AI tools (utility functions now in system/utils)
     const model = runtime.getValue('m') as { tools?: unknown[] };
-    expect(model.tools).toHaveLength(19);
+    expect(model.tools).toHaveLength(13);
   });
 
   test('model without tools parameter has undefined tools', async () => {
@@ -355,7 +355,7 @@ let x = 1
 });
 
 describe('Runtime - Tool Bundles', () => {
-  test('allTools contains all 19 tools including bash and runCode', async () => {
+  test('allTools contains all 13 AI tools including bash and runCode', async () => {
     const ast = parse(`
 import { allTools } from "system/tools"
 let count = ts(allTools) { return allTools.length }
@@ -364,7 +364,7 @@ let names = ts(allTools) { return allTools.map(t => t.name).sort() }
     const runtime = new Runtime(ast, createMockProvider());
     await runtime.run();
 
-    expect(runtime.getValue('count')).toBe(19);
+    expect(runtime.getValue('count')).toBe(13);
     const names = runtime.getValue('names') as string[];
     expect(names).toContain('bash');
     expect(names).toContain('runCode');
@@ -381,7 +381,7 @@ let names = ts(readonlyTools) { return readonlyTools.map(t => t.name).sort() }
     const runtime = new Runtime(ast, createMockProvider());
     await runtime.run();
 
-    expect(runtime.getValue('count')).toBe(12);
+    expect(runtime.getValue('count')).toBe(6);
     const names = runtime.getValue('names') as string[];
     // Should include read-only tools
     expect(names).toContain('readFile');
@@ -409,7 +409,7 @@ let names = ts(safeTools) { return safeTools.map(t => t.name).sort() }
     const runtime = new Runtime(ast, createMockProvider());
     await runtime.run();
 
-    expect(runtime.getValue('count')).toBe(17);
+    expect(runtime.getValue('count')).toBe(11);
     const names = runtime.getValue('names') as string[];
     // Should NOT include bash or runCode
     expect(names).not.toContain('bash');
@@ -430,7 +430,7 @@ let hasRunCode = ts(runCode) { return runCode.name === "runCode" }
     const runtime = new Runtime(ast, createMockProvider());
     await runtime.run();
 
-    expect(runtime.getValue('readCount')).toBe(12);
+    expect(runtime.getValue('readCount')).toBe(6);
     expect(runtime.getValue('hasBash')).toBe(true);
     expect(runtime.getValue('hasRunCode')).toBe(true);
   });
@@ -445,8 +445,8 @@ let names = ts(combined) { return combined.map(t => t.name) }
     const runtime = new Runtime(ast, createMockProvider());
     await runtime.run();
 
-    // readonlyTools (12) + [bash] (1) = 13
-    expect(runtime.getValue('count')).toBe(13);
+    // readonlyTools (6) + [bash] (1) = 7
+    expect(runtime.getValue('count')).toBe(7);
     const names = runtime.getValue('names') as string[];
     expect(names).toContain('readFile');
     expect(names).toContain('bash');
@@ -461,7 +461,7 @@ let count = ts(custom) { return custom.length }
     const runtime = new Runtime(ast, createMockProvider());
     await runtime.run();
 
-    // readonlyTools (12) + bash (1) + runCode (1) = 14
-    expect(runtime.getValue('count')).toBe(14);
+    // readonlyTools (6) + bash (1) + runCode (1) = 8
+    expect(runtime.getValue('count')).toBe(8);
   });
 });

package/src/runtime/types.ts

@@ -794,4 +794,7 @@ export type Instruction =
   | { op: 'destructure_assign'; fields: ExpectedField[]; isConst: boolean; location: SourceLocation }
 
   // Break loop - exit innermost loop with cleanup
-  | { op: 'break_loop'; savedKeys: string[]; contextMode?: ContextMode; label?: string; entryIndex: number; scopeType: 'for' | 'while'; location: SourceLocation };
+  | { op: 'break_loop'; savedKeys: string[]; contextMode?: ContextMode; label?: string; entryIndex: number; scopeType: 'for' | 'while'; location: SourceLocation }
+
+  // Throw error - unwind to function boundary and return error value
+  | { op: 'throw_error'; location: SourceLocation };

package/src/runtime/validation.ts

@@ -24,6 +24,12 @@ export function validateAndCoerce(
   location?: SourceLocation,
   source?: 'ai' | 'user'
 ): { value: unknown; inferredType: VibeType } {
+  // If value is an error VibeValue, pass it through without validation
+  // Errors should propagate unchanged regardless of type annotation
+  if (isVibeValue(value) && value.err) {
+    return { value, inferredType: type };
+  }
+
   // Resolve VibeValue unless this is a direct AI result to an UNTYPED variable
   // (source === 'ai' means the value came directly from an AI call)
   // For typed variables, always resolve so type validation can work on the primitive value

package/src/semantic/analyzer-context.ts

@@ -7,6 +7,7 @@
 import type { SourceLocation } from '../errors';
 import type { SymbolTable, SymbolKind } from './symbol-table';
 import type { TsFunctionSignature } from './ts-signatures';
+import type { VibeType } from '../ast';
 
 /**
  * Context interface passed to analyzer helper functions.
@@ -59,4 +60,5 @@ export interface AnalyzerState {
   inFunction: boolean;
   atTopLevel: boolean;
   loopDepth: number;
+  currentFunctionReturnType: VibeType;  // Track return type for prompt context validation
 }

package/src/semantic/analyzer-visitors.ts

@@ -10,6 +10,8 @@ import { isValidType } from './types';
 import { isCoreFunction } from '../runtime/stdlib/core';
 import { extractFunctionSignature } from './ts-signatures';
 import { resolve, dirname } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { parse } from '../parser/parse';
 import {
   validateModelConfig,
   validateToolDeclaration,
@@ -169,7 +171,15 @@ export function createVisitors(
         if (!state.inFunction) {
           ctx.error('return outside of function', node.location);
         }
-        if (node.value) visitExpression(node.value);
+        if (node.value) {
+          // If returning from a prompt-typed function, validate string literals as prompt context
+          const isPromptReturn = state.currentFunctionReturnType === 'prompt';
+          if (isPromptReturn && (node.value.type === 'StringLiteral' || node.value.type === 'TemplateLiteral')) {
+            validateStringInterpolation(ctx, node.value.value, true, node.value.location);
+          } else {
+            visitExpression(node.value);
+          }
+        }
         break;
 
       case 'BreakStatement':
@@ -178,6 +188,11 @@ export function createVisitors(
         }
         break;
 
+      case 'ThrowStatement':
+        // Visit the message expression for any nested checks
+        visitExpression(node.message);
+        break;
+
       case 'IfStatement':
         visitExpression(node.condition);
         validateConditionType(ctx, node.condition, 'if', getExprType);
@@ -233,6 +248,7 @@ export function createVisitors(
           returnType: node.returnType,
         });
         validateToolDeclaration(ctx, node);
+        visitTool(node);
         break;
 
       case 'AsyncStatement':
@@ -471,9 +487,12 @@ export function createVisitors(
       return;
     }
 
+    // Check for system module imports
+    const isSystemModule = node.source === 'system/utils' || node.source === 'system/tools';
     const isToolImport = node.source === 'system/tools';
 
-    if (node.sourceType === 'ts' && ctx.basePath) {
+    // Extract TypeScript signatures for non-system TS imports
+    if (node.sourceType === 'ts' && ctx.basePath && !isSystemModule) {
       const sourcePath = resolve(dirname(ctx.basePath), node.source);
       for (const spec of node.specifiers) {
         try {
@@ -487,6 +506,12 @@ export function createVisitors(
       }
     }
 
+    // Validate Vibe imports - check that imported symbols exist in source file
+    let exportedNames: Set<string> | null = null;
+    if (node.sourceType === 'vibe' && ctx.basePath) {
+      exportedNames = getExportedNamesFromVibeFile(ctx.basePath, node.source);
+    }
+
     for (const spec of node.specifiers) {
       const existing = ctx.symbols.lookup(spec.local);
       if (existing) {
@@ -502,6 +527,14 @@ export function createVisitors(
           );
         }
       } else {
+        // Validate that imported name exists in source file (for Vibe imports)
+        if (exportedNames !== null && !exportedNames.has(spec.imported)) {
+          ctx.error(
+            `'${spec.imported}' is not exported from '${node.source}'`,
+            node.location
+          );
+        }
+
         // Tool bundles (allTools, readonlyTools, safeTools) are imports, individual tools are 'tool' kind
         const toolBundles = ['allTools', 'readonlyTools', 'safeTools'];
         const importKind = isToolImport && !toolBundles.includes(spec.local) ? 'tool' : 'import';
@@ -510,9 +543,88 @@ export function createVisitors(
     }
   }
 
+  /**
+   * Get the set of exported names from a Vibe source file
+   * Returns null if the file cannot be read/parsed
+   */
+  function getExportedNamesFromVibeFile(basePath: string, importSource: string): Set<string> | null {
+    try {
+      const sourcePath = resolve(dirname(basePath), importSource);
+      if (!existsSync(sourcePath)) {
+        return null; // File doesn't exist - let runtime handle this error
+      }
+
+      const sourceContent = readFileSync(sourcePath, 'utf-8');
+      const sourceAst = parse(sourceContent, { file: sourcePath });
+
+      const exportedNames = new Set<string>();
+      for (const statement of sourceAst.body) {
+        if (statement.type === 'ExportDeclaration') {
+          const decl = statement.declaration;
+          if ('name' in decl) {
+            exportedNames.add(decl.name);
+          }
+        }
+      }
+
+      return exportedNames;
+    } catch {
+      return null; // Parse error or other issue - skip validation
+    }
+  }
+
+  /**
+   * Check if a statement always returns or throws on all code paths.
+   * Used to verify functions with return types exit properly.
+   *
+   * Note: In Vibe, if a function/tool body ends with an expression statement,
+   * that expression's value is implicitly returned.
+   */
+  function alwaysReturnsOrThrows(stmt: AST.Statement, isLastInBlock: boolean = false): boolean {
+    switch (stmt.type) {
+      case 'ReturnStatement':
+      case 'ThrowStatement':
+        return true;
+
+      case 'ExpressionStatement':
+        // An expression at the end of a function/tool body is an implicit return
+        return isLastInBlock;
+
+      case 'IfStatement':
+        // Must have else branch and both branches must return
+        if (!stmt.alternate) {
+          return false;
+        }
+        return alwaysReturnsOrThrows(stmt.consequent, isLastInBlock) &&
+               alwaysReturnsOrThrows(stmt.alternate, isLastInBlock);
+
+      case 'BlockStatement':
+        // Check if any statement in the block guarantees return/throw
+        // For the last statement, also consider implicit returns
+        for (let i = 0; i < stmt.body.length; i++) {
+          const s = stmt.body[i];
+          const isLast = i === stmt.body.length - 1;
+          if (alwaysReturnsOrThrows(s, isLast && isLastInBlock)) {
+            return true;
+          }
+        }
+        return false;
+
+      case 'ForInStatement':
+      case 'WhileStatement':
+        // Loops don't guarantee execution (might iterate 0 times)
+        return false;
+
+      default:
+        return false;
+    }
+  }
+
   function visitFunction(node: AST.FunctionDeclaration): void {
     const wasInFunction = state.inFunction;
+    const prevReturnType = state.currentFunctionReturnType;
     state.inFunction = true;
+    state.currentFunctionReturnType = node.returnType;
     ctx.symbols.enterScope();
 
     for (const param of node.params) {
@@ -526,8 +638,43 @@ export function createVisitors(
 
     visitStatement(node.body);
 
+    // Check that typed functions always return or throw
+    if (node.returnType && !alwaysReturnsOrThrows(node.body, true)) {
+      ctx.error(
+        `Function '${node.name}' has return type '${node.returnType}' but not all code paths return or throw`,
+        node.location
+      );
+    }
+
+    ctx.symbols.exitScope();
+    state.inFunction = wasInFunction;
+    state.currentFunctionReturnType = prevReturnType;
+  }
+
+  function visitTool(node: AST.ToolDeclaration): void {
+    const wasInFunction = state.inFunction;
+    const prevReturnType = state.currentFunctionReturnType;
+    state.inFunction = true;
+    state.currentFunctionReturnType = node.returnType;
+    ctx.symbols.enterScope();
+
+    for (const param of node.params) {
+      ctx.declare(param.name, 'parameter', node.location, { typeAnnotation: param.typeAnnotation });
+    }
+
+    visitStatement(node.body);
+
+    // Tools always have a return type - check that all code paths return or throw
+    if (!alwaysReturnsOrThrows(node.body, true)) {
+      ctx.error(
+        `Tool '${node.name}' has return type '${node.returnType}' but not all code paths return or throw`,
+        node.location
+      );
+    }
+
     ctx.symbols.exitScope();
     state.inFunction = wasInFunction;
+    state.currentFunctionReturnType = prevReturnType;
   }
 
   return { visitStatement, visitExpression };

package/src/semantic/analyzer.ts

@@ -34,6 +34,7 @@ export class SemanticAnalyzer {
       inFunction: false,
       atTopLevel: true,
       loopDepth: 0,
+      currentFunctionReturnType: null,
     };
 
     // Create visitors with context

package/src/semantic/test/fixtures/exports.vibe

@@ -0,0 +1,25 @@
+// Test fixture with exports for import validation tests
+
+export function greet(name: text): text {
+  return "Hello " + name
+}
+
+export function add(a: number, b: number): number {
+  return a + b
+}
+
+export const VERSION = "1.0.0"
+
+export model testModel = {
+  name: "gpt-4",
+  apiKey: "test-key",
+  url: "https://api.example.com"
+}
+
+// This function is NOT exported
+function privateHelper(): text {
+  return "private"
+}
+
+// This constant is NOT exported
+const INTERNAL_SECRET = "hidden"