@vibe-lang/runtime 0.2.5

package/src/semantic/ts-types.ts

@@ -0,0 +1,170 @@
+/**
+ * TypeScript Type Mapping Utilities
+ *
+ * Shared utilities for converting between Vibe types and TypeScript types.
+ * Used by both the ts-block-checker and semantic analyzer.
+ */
+
+/**
+ * Map Vibe type to TypeScript type string.
+ */
+export function vibeTypeToTs(vibeType: string | null): string {
+  if (!vibeType) return 'any';
+
+  // Handle array types first
+  if (vibeType.endsWith('[]')) {
+    const base = vibeType.slice(0, -2);
+    return vibeTypeToTs(base) + '[]';
+  }
+
+  const map: Record<string, string> = {
+    'text': 'string',
+    'prompt': 'string',
+    'number': 'number',
+    'boolean': 'boolean',
+    'json': 'Record<string, unknown>',
+    'null': 'null | undefined',
+  };
+
+  return map[vibeType] ?? 'any';
+}
+
+/**
+ * Map TypeScript type string back to Vibe type.
+ */
+export function tsTypeToVibe(tsType: string): string | null {
+  // Handle array types
+  if (tsType.endsWith('[]')) {
+    const base = tsType.slice(0, -2);
+    const vibeBase = tsTypeToVibe(base);
+    return vibeBase ? `${vibeBase}[]` : null;
+  }
+
+  // Handle Array<T> syntax
+  if (tsType.startsWith('Array<') && tsType.endsWith('>')) {
+    const base = tsType.slice(6, -1);
+    const vibeBase = tsTypeToVibe(base);
+    return vibeBase ? `${vibeBase}[]` : null;
+  }
+
+  // Direct mappings
+  const map: Record<string, string> = {
+    'string': 'text',
+    'number': 'number',
+    'boolean': 'boolean',
+    'void': 'null',
+    'undefined': 'null',
+    'null': 'null',
+    'any': 'json',
+    'unknown': 'json',
+    'object': 'json',
+  };
+
+  if (map[tsType]) {
+    return map[tsType];
+  }
+
+  // Handle Record types and other object-like types as json
+  if (tsType.startsWith('Record<') || tsType.startsWith('{')) {
+    return 'json';
+  }
+
+  // Handle union types - try to find a common type
+  if (tsType.includes(' | ')) {
+    const types = tsType.split(' | ').map(t => t.trim());
+    // Filter out null/undefined
+    const nonNullTypes = types.filter(t => t !== 'null' && t !== 'undefined');
+    if (nonNullTypes.length === 1) {
+      return tsTypeToVibe(nonNullTypes[0]);
+    }
+    // Mixed types become json
+    return 'json';
+  }
+
+  // Unknown types become json (safest)
+  return 'json';
+}
+
+/**
+ * Check if a Vibe type is compatible with a TypeScript type.
+ */
+export function isVibeTypeCompatibleWithTs(vibeType: string, tsType: string): boolean {
+  // Map Vibe types to their TS equivalents
+  const vibeToTs: Record<string, string> = {
+    'text': 'string',
+    'prompt': 'string',
+    'number': 'number',
+    'boolean': 'boolean',
+    'null': 'null',
+  };
+
+  // Handle array types
+  if (vibeType.endsWith('[]')) {
+    const vibeBase = vibeType.slice(0, -2);
+    // TS array types can be T[] or Array<T>
+    if (tsType.endsWith('[]')) {
+      const tsBase = tsType.slice(0, -2);
+      return isVibeTypeCompatibleWithTs(vibeBase, tsBase);
+    }
+    if (tsType.startsWith('Array<') && tsType.endsWith('>')) {
+      const tsBase = tsType.slice(6, -1);
+      return isVibeTypeCompatibleWithTs(vibeBase, tsBase);
+    }
+    // Check against any[]
+    if (tsType === 'any[]' || tsType === 'Array<any>') return true;
+    return false;
+  }
+
+  // json is compatible with object-like types
+  if (vibeType === 'json') {
+    return isTsTypeObjectLike(tsType);
+  }
+
+  // Get the mapped TS type for the Vibe type
+  const mappedTsType = vibeToTs[vibeType];
+  if (!mappedTsType) {
+    // Unknown Vibe type - skip checking
+    return true;
+  }
+
+  // Direct match
+  if (mappedTsType === tsType) return true;
+
+  // 'any' accepts everything
+  if (tsType === 'any') return true;
+
+  // 'unknown' accepts everything at assignment
+  if (tsType === 'unknown') return true;
+
+  // Handle union types (e.g., "string | null")
+  if (tsType.includes(' | ')) {
+    const unionTypes = tsType.split(' | ').map(t => t.trim());
+    return unionTypes.some(ut => isVibeTypeCompatibleWithTs(vibeType, ut));
+  }
+
+  return false;
+}
+
+/**
+ * Check if a TypeScript type is object-like (accepts json).
+ */
+export function isTsTypeObjectLike(tsType: string): boolean {
+  // Direct object-like types
+  if (tsType === 'object') return true;
+  if (tsType === 'any') return true;
+  if (tsType === 'unknown') return true;
+
+  // Record types
+  if (tsType.startsWith('Record<')) return true;
+
+  // Index signature types like { [key: string]: any }
+  if (tsType.startsWith('{') && tsType.includes('[')) return true;
+
+  // Generic object types (interfaces, type aliases)
+  // If it starts with uppercase and isn't a known primitive, assume it's object-like
+  if (/^[A-Z]/.test(tsType) && !['String', 'Number', 'Boolean'].includes(tsType)) {
+    return true;
+  }
+
+  return false;
+}

package/src/semantic/types.ts

@@ -0,0 +1,58 @@
+// Type validation and compatibility utilities
+
+/**
+ * Valid base types in the Vibe language.
+ */
+export const VALID_BASE_TYPES = ['text', 'json', 'prompt', 'boolean', 'number', 'model'] as const;
+
+/**
+ * Get the base type from a type annotation (strips array brackets).
+ * e.g., "text[][]" -> "text", "number" -> "number"
+ */
+export function getBaseType(type: string): string {
+  return type.replace(/\[\]/g, '');
+}
+
+/**
+ * Check if a type annotation string is a valid Vibe type.
+ */
+export function isValidType(type: string): boolean {
+  const baseType = getBaseType(type);
+  return VALID_BASE_TYPES.includes(baseType as typeof VALID_BASE_TYPES[number]);
+}
+
+/**
+ * Check if sourceType can be assigned to targetType.
+ */
+export function typesCompatible(sourceType: string, targetType: string): boolean {
+  // Exact match
+  if (sourceType === targetType) return true;
+
+  // null is compatible with most types, but NOT boolean (booleans must be true or false)
+  if (sourceType === 'null' && targetType !== 'boolean') return true;
+
+  // text and prompt are compatible
+  if ((sourceType === 'text' || sourceType === 'prompt') &&
+      (targetType === 'text' || targetType === 'prompt')) {
+    return true;
+  }
+
+  // json accepts text (will be parsed at runtime)
+  if (targetType === 'json' && sourceType === 'text') {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Validate that a string is valid JSON.
+ */
+export function isValidJson(value: string): boolean {
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/tests/fixtures/conditional-logic.vibe

@@ -0,0 +1,14 @@
+// Program with conditional logic
+
+model m = { name: "gpt-4", apiKey: "test", url: "http://test" }
+let isPremium: boolean = true
+let response = ""
+
+if isPremium {
+  let greeting = vibe "Generate a premium greeting" m default
+  response = greeting
+} else {
+  response = "Standard greeting"
+}
+
+response

package/tests/fixtures/function-call.vibe

@@ -0,0 +1,16 @@
+// Program with functions and AI calls
+
+model m = { name: "gpt-4", apiKey: "test", url: "http://test" }
+
+function generateStory(topic: text) {
+  let aiPrompt = "Write a short story about {topic}"
+  return vibe aiPrompt m default
+}
+
+function summarize(content: text) {
+  return vibe "Summarize this: {content}" m default
+}
+
+let story = generateStory("a brave knight")
+let summary = summarize(story)
+summary

package/tests/fixtures/imports/cycle-detection/a.vibe

@@ -0,0 +1,6 @@
+import { funcB } from "./b.vibe"
+
+export function funcA(x: text): text {
+  let y = funcB(x)
+  return y
+}

package/tests/fixtures/imports/cycle-detection/b.vibe

@@ -0,0 +1,5 @@
+import { funcA } from "./a.vibe"
+
+export function funcB(x: text): text {
+  return x
+}

package/tests/fixtures/imports/cycle-detection/main.vibe

@@ -0,0 +1,3 @@
+import { funcA } from "./a.vibe"
+
+let result = funcA("test")

package/tests/fixtures/imports/module-isolation/main-b.vibe

@@ -0,0 +1,8 @@
+// main-b.vibe - tests moduleB's isolation
+
+const x = "MAIN"
+
+import { getX } from "./moduleB.vibe"
+
+// getX() should return "B" (from moduleB), not "MAIN"
+let result = getX()

package/tests/fixtures/imports/module-isolation/main.vibe

@@ -0,0 +1,9 @@
+// main.vibe - tests that imported function sees its own module's global
+// NOT the caller's global
+
+const x = "MAIN"
+
+import { getX } from "./moduleA.vibe"
+
+// getX() should return "A" (from moduleA), not "MAIN"
+let result = getX()

package/tests/fixtures/imports/module-isolation/moduleA.vibe

@@ -0,0 +1,6 @@
+// moduleA.vibe - has its own global x = "A"
+const x = "A"
+
+export function getX() {
+  return x
+}

package/tests/fixtures/imports/module-isolation/moduleB.vibe

@@ -0,0 +1,6 @@
+// moduleB.vibe - has its own global x = "B"
+const x = "B"
+
+export function getX() {
+  return x
+}

package/tests/fixtures/imports/nested-import/helper.vibe

@@ -0,0 +1,6 @@
+import { formatName } from "./utils.ts"
+
+export function formatGreeting(firstName: text, lastName: text): text {
+  let fullName = formatName(firstName, lastName)
+  return fullName
+}

package/tests/fixtures/imports/nested-import/main.vibe

@@ -0,0 +1,3 @@
+import { formatGreeting } from "./helper.vibe"
+
+let greeting = formatGreeting("John", "Doe")

package/tests/fixtures/imports/nested-import/utils.ts

@@ -0,0 +1,3 @@
+export function formatName(firstName: string, lastName: string): string {
+  return `${firstName} ${lastName}`;
+}

package/tests/fixtures/imports/nested-isolation/file2.vibe

@@ -0,0 +1,15 @@
+// file2.vibe - imports from file3
+import { getC } from "./file3.vibe"
+
+const x = "B"
+
+export function getB() {
+  return x
+}
+
+// This function calls into file3 - should still see file3's x
+export function getBAndC() {
+  let b = x
+  let c = getC()
+  return b + c
+}

package/tests/fixtures/imports/nested-isolation/file3.vibe

@@ -0,0 +1,10 @@
+// file3.vibe - base module
+const x = "C"
+
+export function getC() {
+  return x
+}
+
+export function getCTwice() {
+  return x + x
+}

package/tests/fixtures/imports/nested-isolation/main.vibe

@@ -0,0 +1,21 @@
+// main.vibe - imports from file2 and file3
+// Tests nested import scope isolation
+
+import { getB, getBAndC } from "./file2.vibe"
+import { getC, getCTwice } from "./file3.vibe"
+
+const x = "A"
+
+// Each function should see its own module's x:
+// - getB() should return "B" (from file2)
+// - getC() should return "C" (from file3)
+// - getCTwice() should return "CC" (from file3)
+// - getBAndC() should return "BC" (B from file2, C via file3's getC)
+
+let resultB = getB()
+let resultC = getC()
+let resultCC = getCTwice()
+let resultBC = getBAndC()
+
+// Final result combines all to verify isolation
+let result = resultB + resultC + resultCC + resultBC

package/tests/fixtures/imports/pure-cycle/a.vibe

@@ -0,0 +1,5 @@
+import { funcB } from "./b.vibe"
+
+export function funcA(x: text): text {
+  return x
+}

package/tests/fixtures/imports/pure-cycle/b.vibe

@@ -0,0 +1,5 @@
+import { funcA } from "./a.vibe"
+
+export function funcB(x: text): text {
+  return x
+}

package/tests/fixtures/imports/pure-cycle/main.vibe

@@ -0,0 +1,3 @@
+import { funcB } from "./b.vibe"
+
+let result = funcB("test")

package/tests/fixtures/imports/ts-boolean/checks.ts

@@ -0,0 +1,14 @@
+export function alwaysTrue(): boolean {
+  return true;
+}
+
+export function alwaysFalse(): boolean {
+  return false;
+}
+
+export function isNotEmpty(str: string): boolean {
+  return str.length > 0;
+}
+
+export const FEATURE_ENABLED = true;
+export const DEBUG_MODE = false;

package/tests/fixtures/imports/ts-boolean/main.vibe

@@ -0,0 +1,10 @@
+import { FEATURE_ENABLED } from "./checks.ts"
+
+// Use imported TS boolean constant in if condition
+let enabled: boolean = FEATURE_ENABLED
+let result = "disabled"
+if enabled {
+  result = "enabled"
+}
+
+result

package/tests/fixtures/imports/ts-boolean/type-mismatch.vibe

@@ -0,0 +1,5 @@
+import { add } from "../ts-import/math.ts"
+
+// This should fail - add returns number, not boolean
+let result: boolean = add(1, 2)
+result

package/tests/fixtures/imports/ts-boolean/use-constant.vibe

@@ -0,0 +1,18 @@
+import { alwaysTrue, isNotEmpty } from "./checks.ts"
+
+// Test TS function returning boolean (no args)
+let check1: boolean = alwaysTrue()
+let result1 = "failed"
+if check1 {
+  result1 = "passed"
+}
+
+// Test TS function returning boolean (string arg)
+let testStr = "hello"
+let check2: boolean = isNotEmpty(testStr)
+let result2 = "empty"
+if check2 {
+  result2 = "not empty"
+}
+
+result2

package/tests/fixtures/imports/ts-error-handling/helpers.ts

@@ -0,0 +1,42 @@
+// TypeScript helpers that throw errors for testing error handling
+
+/**
+ * A function that always throws an error.
+ * Used to test that stack traces include the correct file and line.
+ */
+export function alwaysThrows(): never {
+  throw new Error('This function always throws');
+}
+
+/**
+ * A function that throws when given invalid input.
+ */
+export function validatePositive(n: number): number {
+  if (n < 0) {
+    throw new RangeError(`Expected positive number, got ${n}`);
+  }
+  return n;
+}
+
+/**
+ * A function that accesses a property on null (TypeError).
+ */
+export function accessNullProperty(): string {
+  const obj: { name: string } | null = null;
+  return obj!.name; // This will throw TypeError
+}
+
+/**
+ * A nested function call that throws - to test stack trace depth.
+ */
+export function outerFunction(): void {
+  innerFunction();
+}
+
+function innerFunction(): void {
+  deepFunction();
+}
+
+function deepFunction(): never {
+  throw new Error('Error from deep in the call stack');
+}

package/tests/fixtures/imports/ts-error-handling/main.vibe

@@ -0,0 +1,5 @@
+// Test error handling from imported TS functions
+import { alwaysThrows, validatePositive, accessNullProperty, outerFunction } from "./helpers.ts"
+
+// This will throw an error
+let result = alwaysThrows()

package/tests/fixtures/imports/ts-import/main.vibe

@@ -0,0 +1,4 @@
+import { add, multiply } from "./math.ts"
+
+let sum = add("5", "3")
+let product = multiply("4", "7")

package/tests/fixtures/imports/ts-import/math.ts

@@ -0,0 +1,9 @@
+export function add(a: number, b: number): number {
+  return a + b;
+}
+
+export function multiply(a: number, b: number): number {
+  return a * b;
+}
+
+export const PI = 3.14159;

package/tests/fixtures/imports/ts-variables/call-non-function.vibe

@@ -0,0 +1,5 @@
+// Import a TS variable (not a function)
+import { MESSAGE } from "./data.ts"
+
+// Try to call it as a function - should fail
+let result = MESSAGE("arg")

package/tests/fixtures/imports/ts-variables/data.ts

@@ -0,0 +1,10 @@
+// Test various TS exports - functions and non-functions
+
+export const PI = 3.14159;
+export const CONFIG = { name: "test", version: "1.0" };
+export const ITEMS = ["a", "b", "c"];
+export const MESSAGE = "Hello from TypeScript";
+
+export function greet(name: string): string {
+  return `Hello, ${name}!`;
+}

package/tests/fixtures/imports/ts-variables/import-json.vibe

@@ -0,0 +1,5 @@
+// Import a TS object variable
+import { CONFIG } from "./data.ts"
+
+// Assign to a json-typed variable - should work
+let config: json = CONFIG

package/tests/fixtures/imports/ts-variables/import-type-mismatch.vibe

@@ -0,0 +1,5 @@
+// Import a TS object variable but try to assign to text type
+import { CONFIG } from "./data.ts"
+
+// This should fail - CONFIG is an object, not a string
+let config: text = CONFIG

package/tests/fixtures/imports/ts-variables/import-variable.vibe

@@ -0,0 +1,5 @@
+// Import a TS variable (not a function)
+import { MESSAGE } from "./data.ts"
+
+// Assign to a text-typed variable - should work
+let greeting: text = MESSAGE

package/tests/fixtures/imports/vibe-import/greet.vibe

@@ -0,0 +1,5 @@
+model gpt = { name: "gpt-4" }
+
+export function greet(name: text): text {
+  return vibe "Say hello to {name}" gpt default
+}

package/tests/fixtures/imports/vibe-import/main.vibe

@@ -0,0 +1,3 @@
+import { greet } from "./greet.vibe"
+
+let greeting = greet("Alice")

package/tests/fixtures/multiple-ai-calls.vibe

@@ -0,0 +1,10 @@
+// Program with multiple sequential AI calls
+
+model m = { name: "gpt-4", apiKey: "test", url: "http://test" }
+const topic = "machine learning"
+
+let overview = vibe "Give a one-sentence overview of {topic}" m default
+let details = vibe "Expand on this: {overview}" m default
+let summary = vibe "Summarize in 5 words: {details}" m default
+
+summary

package/tests/fixtures/simple-greeting.vibe

@@ -0,0 +1,6 @@
+// Simple greeting program with AI call
+
+model m = { name: "gpt-4", apiKey: "test", url: "http://test" }
+let name = "Alice"
+let greeting = vibe "Generate a friendly greeting for {name}" m default
+greeting

package/tests/fixtures/template-literals.vibe

@@ -0,0 +1,11 @@
+// Program with template literals and string interpolation
+
+model m = { name: "gpt-4", apiKey: "test", url: "http://test" }
+const firstName = "John"
+const lastName = "Doe"
+
+// Template literals now use {var} syntax (unified with regular strings)
+let fullName = `{firstName} {lastName}`
+let message = vibe "Generate a welcome message for {fullName}" m default
+
+message