@vibe-lang/runtime 0.2.5

package/src/semantic/test/undefined-variables.test.ts

@@ -0,0 +1,163 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { analyze } from '../index';
+
+describe('Semantic Errors - Undefined Variables', () => {
+  // ============================================================================
+  // Basic undefined variable usage
+  // ============================================================================
+
+  test('using undefined variable in expression', () => {
+    const ast = parse(`
+let x = undefinedVar
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'undefinedVar' is not defined");
+  });
+
+  test('using undefined variable in function call', () => {
+    const ast = parse(`
+let x = unknownFunc()
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'unknownFunc' is not defined");
+  });
+
+  test('using undefined variable as function argument', () => {
+    const ast = parse(`
+function greet(name: text): text {
+  return name
+}
+let x = greet(unknownArg)
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'unknownArg' is not defined");
+  });
+
+  // ============================================================================
+  // Undefined in vibe expressions
+  // ============================================================================
+
+  test('using undefined variable as vibe prompt', () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+let x: text = vibe undefinedPrompt myModel default
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'undefinedPrompt' is not defined");
+  });
+
+  test('using undefined model in vibe expression', () => {
+    const ast = parse(`
+let x: text = vibe "prompt" undefinedModel default
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'undefinedModel' is not defined");
+  });
+
+  test('using undefined context variable in vibe expression', () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+let x: text = vibe "prompt" myModel undefinedContext
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'undefinedContext' is not defined");
+  });
+
+  // ============================================================================
+  // Undefined in if statements
+  // ============================================================================
+
+  test('using undefined variable in if condition', () => {
+    const ast = parse(`
+if undefinedCond {
+  let x = "yes"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'undefinedCond' is not defined");
+  });
+
+  // ============================================================================
+  // Undefined in return statements
+  // ============================================================================
+
+  test('returning undefined variable', () => {
+    const ast = parse(`
+function test() {
+  return undefinedReturn
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'undefinedReturn' is not defined");
+  });
+
+  // ============================================================================
+  // Multiple undefined variables
+  // ============================================================================
+
+  test('multiple undefined variables', () => {
+    const ast = parse(`
+let a = undefined1
+let b = undefined2
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+    expect(errors[0].message).toBe("'undefined1' is not defined");
+    expect(errors[1].message).toBe("'undefined2' is not defined");
+  });
+
+  // ============================================================================
+  // Variable used before declaration
+  // ============================================================================
+
+  test('variable used before declaration', () => {
+    const ast = parse(`
+let x = y
+let y = "hello"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("'y' is not defined");
+  });
+
+  // ============================================================================
+  // Valid cases (should have no errors)
+  // ============================================================================
+
+  test('using declared variable', () => {
+    const ast = parse(`
+let x = "hello"
+let y = x
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('using function parameter', () => {
+    const ast = parse(`
+function greet(name: text): text {
+  return name
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('using model in vibe expression', () => {
+    const ast = parse(`
+model myModel = { name: "test", apiKey: "key", url: "http://test" }
+let x: text = vibe "prompt" myModel default
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+});

package/src/semantic/ts-block-checker.ts

@@ -0,0 +1,204 @@
+/**
+ * TypeScript Block Type Checker
+ *
+ * Type-checks ts() block bodies by compiling virtual TypeScript in memory.
+ * This catches type errors at compile time before the Vibe program runs.
+ */
+import ts from 'typescript';
+import type { SourceLocation } from '../errors';
+import { vibeTypeToTs, tsTypeToVibe } from './ts-types';
+
+export interface TsBlockError {
+  message: string;
+  location: SourceLocation;
+}
+
+/**
+ * Parameter info for ts() block type checking.
+ */
+export interface TsBlockParam {
+  name: string;
+  vibeType: string | null;
+}
+
+/**
+ * Create compiler options for virtual TypeScript compilation.
+ */
+function createCompilerOptions(): ts.CompilerOptions {
+  return {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    noEmit: true,
+    strict: false,  // Less strict to avoid spurious errors
+    skipLibCheck: true,
+    noImplicitAny: false,  // Allow implicit any for external references
+  };
+}
+
+/**
+ * Create a virtual compiler host that serves in-memory TypeScript code.
+ */
+function createVirtualCompilerHost(
+  fileName: string,
+  code: string,
+  options: ts.CompilerOptions
+): { host: ts.CompilerHost; sourceFile: ts.SourceFile } {
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    code,
+    ts.ScriptTarget.ESNext,
+    true
+  );
+
+  const defaultHost = ts.createCompilerHost(options);
+  const host: ts.CompilerHost = {
+    ...defaultHost,
+    getSourceFile: (name, languageVersion) => {
+      if (name === fileName) {
+        return sourceFile;
+      }
+      return defaultHost.getSourceFile(name, languageVersion);
+    },
+    fileExists: (name) => {
+      if (name === fileName) return true;
+      return defaultHost.fileExists(name);
+    },
+    readFile: (name) => {
+      if (name === fileName) return code;
+      return defaultHost.readFile(name);
+    },
+  };
+
+  return { host, sourceFile };
+}
+
+/**
+ * Generate virtual TypeScript function code from ts() block params and body.
+ */
+function generateVirtualCode(params: TsBlockParam[], body: string): string {
+  const paramList = params
+    .map((p) => `${p.name}: ${vibeTypeToTs(p.vibeType)}`)
+    .join(', ');
+  return `function __tsBlock(${paramList}) {\n${body}\n}`;
+}
+
+/**
+ * Type-check a ts() block body with the given parameters.
+ *
+ * Only checks for type errors related to the provided parameters.
+ * External function calls and variables are not checked since we don't
+ * have context about what's available in the runtime environment.
+ *
+ * @param params - Array of parameter names and their Vibe types
+ * @param body - The TypeScript code inside the ts() block
+ * @param blockLocation - Location of the ts() block in the Vibe source
+ * @returns Array of type errors found
+ */
+export function checkTsBlockTypes(
+  params: TsBlockParam[],
+  body: string,
+  blockLocation: SourceLocation
+): TsBlockError[] {
+  // Skip type checking if there are no typed parameters
+  // We can only meaningfully check types when we have parameter type info
+  const typedParams = params.filter(p => p.vibeType !== null);
+  if (typedParams.length === 0) {
+    return [];
+  }
+
+  const virtualFileName = '__virtual_ts_block__.ts';
+  const virtualCode = generateVirtualCode(params, body);
+  const compilerOptions = createCompilerOptions();
+  const { host } = createVirtualCompilerHost(virtualFileName, virtualCode, compilerOptions);
+
+  // Create program and get diagnostics
+  const program = ts.createProgram([virtualFileName], compilerOptions, host);
+  const diagnostics = ts.getPreEmitDiagnostics(program);
+
+  // Filter diagnostics to only include type errors related to our parameters
+  // Error code 2304 is "Cannot find name" - we ignore these for external refs
+  const paramNames = new Set(params.map(p => p.name));
+  const relevantErrors: TsBlockError[] = [];
+
+  for (const d of diagnostics) {
+    if (d.category !== ts.DiagnosticCategory.Error) continue;
+
+    const message = ts.flattenDiagnosticMessageText(d.messageText, '\n');
+
+    // Skip "Cannot find name" errors for external functions/variables
+    // These are expected since ts() blocks can call external code
+    if (d.code === 2304) {
+      // Only report if it's about one of our parameters (shouldn't happen
+      // since we define them, but just in case)
+      const match = message.match(/Cannot find name '(\w+)'/);
+      if (match && !paramNames.has(match[1])) {
+        continue;
+      }
+    }
+
+    // Map location back to original block
+    let errorLocation = blockLocation;
+    if (d.file && d.start !== undefined) {
+      const { line } = d.file.getLineAndCharacterOfPosition(d.start);
+      const originalLine = line - 1;
+      if (originalLine >= 0) {
+        errorLocation = {
+          ...blockLocation,
+          line: blockLocation.line + originalLine,
+        };
+      }
+    }
+
+    relevantErrors.push({
+      message: `TypeScript error in ts() block: ${message}`,
+      location: errorLocation,
+    });
+  }
+
+  return relevantErrors;
+}
+
+/**
+ * Infer the return type of a ts() block by compiling it and extracting the return type.
+ *
+ * @param params - Array of parameter names and their Vibe types
+ * @param body - The TypeScript code inside the ts() block
+ * @returns The inferred Vibe type, or null if it cannot be determined
+ */
+export function inferTsBlockReturnType(
+  params: TsBlockParam[],
+  body: string
+): string | null {
+  const virtualFileName = '__virtual_ts_block_infer__.ts';
+  const virtualCode = generateVirtualCode(params, body);
+  const compilerOptions = createCompilerOptions();
+  const { host } = createVirtualCompilerHost(virtualFileName, virtualCode, compilerOptions);
+
+  const program = ts.createProgram([virtualFileName], compilerOptions, host);
+  const checker = program.getTypeChecker();
+  const source = program.getSourceFile(virtualFileName);
+
+  if (!source) return null;
+
+  // Find the function declaration and get its return type
+  let returnType: string | null = null;
+
+  function visit(node: ts.Node) {
+    if (returnType !== null) return;
+
+    if (ts.isFunctionDeclaration(node) && node.name?.text === '__tsBlock') {
+      const signature = checker.getSignatureFromDeclaration(node);
+      if (signature) {
+        const tsReturnType = checker.getReturnTypeOfSignature(signature);
+        const tsTypeString = checker.typeToString(tsReturnType);
+        returnType = tsTypeToVibe(tsTypeString);
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(source);
+
+  return returnType;
+}

package/src/semantic/ts-signatures.ts

@@ -0,0 +1,194 @@
+/**
+ * TypeScript Signature Extraction Utility
+ *
+ * Extracts function signatures from TypeScript files at compile time
+ * for use in semantic analysis of Vibe programs.
+ */
+import ts from 'typescript';
+
+export interface TsFunctionSignature {
+  name: string;
+  params: Array<{ name: string; tsType: string; optional: boolean }>;
+  returnType: string;
+}
+
+// Cache to avoid re-parsing same file
+const signatureCache = new Map<string, Map<string, TsFunctionSignature>>();
+
+/**
+ * Extract a function signature from a TypeScript file.
+ *
+ * @param sourceFile - Path to the TypeScript source file
+ * @param funcName - Name of the function to extract
+ * @returns The function signature, or undefined if not found
+ */
+export function extractFunctionSignature(
+  sourceFile: string,
+  funcName: string
+): TsFunctionSignature | undefined {
+  // Check cache first
+  const fileCache = signatureCache.get(sourceFile);
+  if (fileCache?.has(funcName)) {
+    return fileCache.get(funcName);
+  }
+
+  // Create TypeScript program to parse the file
+  const program = ts.createProgram([sourceFile], {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.NodeNext,
+    strict: true,
+  });
+
+  const checker = program.getTypeChecker();
+  const source = program.getSourceFile(sourceFile);
+
+  if (!source) {
+    return undefined;
+  }
+
+  // Walk AST to find function declaration or arrow function export
+  let result: TsFunctionSignature | undefined;
+
+  function visit(node: ts.Node) {
+    if (result) return; // Already found
+
+    // Handle: export function funcName(...) { }
+    if (ts.isFunctionDeclaration(node) && node.name?.text === funcName) {
+      result = extractSignatureFromFunction(node, checker, funcName);
+      return;
+    }
+
+    // Handle: export const funcName = (...) => { }
+    // or: export const funcName = function(...) { }
+    if (ts.isVariableStatement(node)) {
+      for (const decl of node.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name) && decl.name.text === funcName && decl.initializer) {
+          if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {
+            result = extractSignatureFromFunction(decl.initializer, checker, funcName);
+            return;
+          }
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(source);
+
+  // Cache the result
+  if (result) {
+    if (!signatureCache.has(sourceFile)) {
+      signatureCache.set(sourceFile, new Map());
+    }
+    signatureCache.get(sourceFile)!.set(funcName, result);
+  }
+
+  return result;
+}
+
+/**
+ * Extract signature from a function-like declaration.
+ */
+function extractSignatureFromFunction(
+  node: ts.FunctionDeclaration | ts.ArrowFunction | ts.FunctionExpression,
+  checker: ts.TypeChecker,
+  funcName: string
+): TsFunctionSignature {
+  const params = node.parameters.map((param) => {
+    const paramType = checker.getTypeAtLocation(param);
+    return {
+      name: param.name.getText(),
+      tsType: checker.typeToString(paramType),
+      optional: !!param.questionToken || !!param.initializer,
+    };
+  });
+
+  // Get return type from signature
+  const sig = checker.getSignatureFromDeclaration(node);
+  const returnType = sig ? checker.typeToString(sig.getReturnType()) : 'void';
+
+  return {
+    name: funcName,
+    params,
+    returnType,
+  };
+}
+
+/**
+ * Extract all exported function signatures from a TypeScript file.
+ *
+ * @param sourceFile - Path to the TypeScript source file
+ * @returns Map of function name to signature
+ */
+export function extractAllFunctionSignatures(
+  sourceFile: string
+): Map<string, TsFunctionSignature> {
+  const results = new Map<string, TsFunctionSignature>();
+
+  const program = ts.createProgram([sourceFile], {
+    target: ts.ScriptTarget.ESNext,
+    module: ts.ModuleKind.ESNext,
+    moduleResolution: ts.ModuleResolutionKind.NodeNext,
+    strict: true,
+  });
+
+  const checker = program.getTypeChecker();
+  const source = program.getSourceFile(sourceFile);
+
+  if (!source) {
+    return results;
+  }
+
+  function visit(node: ts.Node) {
+    // Handle: export function funcName(...) { }
+    if (ts.isFunctionDeclaration(node) && node.name) {
+      const isExported = node.modifiers?.some(
+        (m) => m.kind === ts.SyntaxKind.ExportKeyword
+      );
+      if (isExported) {
+        const sig = extractSignatureFromFunction(node, checker, node.name.text);
+        results.set(node.name.text, sig);
+      }
+    }
+
+    // Handle: export const funcName = (...) => { }
+    if (ts.isVariableStatement(node)) {
+      const isExported = node.modifiers?.some(
+        (m) => m.kind === ts.SyntaxKind.ExportKeyword
+      );
+      if (isExported) {
+        for (const decl of node.declarationList.declarations) {
+          if (ts.isIdentifier(decl.name) && decl.initializer) {
+            if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {
+              const sig = extractSignatureFromFunction(decl.initializer, checker, decl.name.text);
+              results.set(decl.name.text, sig);
+            }
+          }
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(source);
+
+  // Update cache
+  if (!signatureCache.has(sourceFile)) {
+    signatureCache.set(sourceFile, new Map());
+  }
+  for (const [name, sig] of results) {
+    signatureCache.get(sourceFile)!.set(name, sig);
+  }
+
+  return results;
+}
+
+/**
+ * Clear the signature cache (useful for testing or when files change).
+ */
+export function clearSignatureCache(): void {
+  signatureCache.clear();
+}