@vibe-lang/runtime 0.2.5

package/src/runtime/exec/functions.ts

@@ -0,0 +1,305 @@
+// Function call execution
+
+import * as AST from '../../ast';
+import type { SourceLocation } from '../../errors';
+import type { RuntimeState, StackFrame } from '../types';
+import { resolveValue, createVibeValue } from '../types';
+import type { VibeToolValue } from '../tools/types';
+import { createFrame } from '../state';
+import { getImportedVibeFunction, getImportedVibeFunctionModulePath } from '../modules';
+import { getCoreFunction } from '../stdlib/core';
+import { validateAndCoerce } from '../validation';
+import { scheduleAsyncOperation, isInAsyncContext } from '../async/scheduling';
+
+/**
+ * Create a new frame with validated parameters for a Vibe function call.
+ * @param modulePath - If set, this frame belongs to an imported module (for scope isolation)
+ */
+export function createFunctionFrame(
+  funcName: string,
+  params: AST.FunctionParameter[],
+  args: unknown[],
+  modulePath?: string
+): StackFrame {
+  const newFrame = createFrame(funcName, 0);
+
+  // Set module path for imported functions (enables module scope isolation)
+  if (modulePath) {
+    newFrame.modulePath = modulePath;
+  }
+
+  for (let i = 0; i < params.length; i++) {
+    const param = params[i];
+    const argValue = args[i] ?? null;
+
+    const { value: validatedValue } = validateAndCoerce(
+      argValue,
+      param.typeAnnotation,
+      param.name
+    );
+
+    newFrame.locals[param.name] = createVibeValue(validatedValue, {
+      isConst: false,
+      typeAnnotation: param.typeAnnotation,
+    });
+    // Include snapshotted value in ordered entries for context tracking
+    newFrame.orderedEntries.push({
+      kind: 'variable' as const,
+      name: param.name,
+      value: validatedValue,
+      type: param.typeAnnotation,
+      isConst: false,  // Parameters are not const
+    });
+  }
+
+  return newFrame;
+}
+
+/**
+ * Execute a Vibe function (local or imported) by pushing its body onto the instruction stack.
+ * Note: Functions always forget context on exit (like traditional callstack).
+ * @param modulePath - If set, this function belongs to an imported module (for scope isolation)
+ */
+function executeVibeFunction(
+  state: RuntimeState,
+  func: AST.FunctionDeclaration,
+  args: unknown[],
+  newValueStack: unknown[],
+  modulePath?: string
+): RuntimeState {
+  const newFrame = createFunctionFrame(func.name, func.params, args, modulePath);
+
+  const bodyInstructions = func.body.body.map((s) => ({
+    op: 'exec_statement' as const,
+    stmt: s,
+    location: s.location,
+  }));
+
+  return {
+    ...state,
+    valueStack: newValueStack,
+    callStack: [...state.callStack, newFrame],
+    instructionStack: [
+      ...bodyInstructions,
+      { op: 'pop_frame', location: func.body.location },
+      ...state.instructionStack,
+    ],
+    lastResult: null,
+  };
+}
+
+/**
+ * Schedule a Vibe function for async execution.
+ * Creates an async operation that will clone state and run the function in isolation.
+ */
+function scheduleAsyncVibeFunction(
+  state: RuntimeState,
+  funcName: string,
+  args: unknown[],
+  newValueStack: unknown[],
+  modulePath?: string
+): RuntimeState {
+  // Use shared scheduling helper, then update valueStack
+  const newState = scheduleAsyncOperation(
+    state,
+    {
+      type: 'vibe-function',
+      vibeFuncDetails: {
+        funcName,
+        args,
+        modulePath,
+      },
+    },
+    'async_vibe_function_scheduled'
+  );
+  return { ...newState, valueStack: newValueStack };
+}
+
+/**
+ * Execute function call - handles local Vibe, imported Vibe, and imported TS functions.
+ * Note: Functions always forget context on exit (like traditional callstack).
+ */
+export function execCallFunction(
+  state: RuntimeState,
+  _funcName: string,
+  argCount: number,
+  location: SourceLocation
+): RuntimeState {
+  // Get args and callee from value stack, unwrapping VibeValues
+  const rawArgs = state.valueStack.slice(-argCount);
+  const rawCallee = state.valueStack[state.valueStack.length - argCount - 1];
+  const newValueStack = state.valueStack.slice(0, -(argCount + 1));
+
+  // Unwrap VibeValue for callee and args
+  const callee = resolveValue(rawCallee);
+  const args = rawArgs.map(arg => resolveValue(arg));
+
+  // Handle local Vibe function
+  if (typeof callee === 'object' && callee !== null && '__vibeFunction' in callee) {
+    const funcName = (callee as { __vibeFunction: boolean; name: string }).name;
+    const func = state.functions[funcName];
+
+    if (!func) {
+      throw new Error(`ReferenceError: '${funcName}' is not defined`);
+    }
+
+    // Check if we're in async context (variable, destructuring, or fire-and-forget)
+    if (isInAsyncContext(state)) {
+      return scheduleAsyncVibeFunction(state, funcName, args, newValueStack);
+    }
+
+    return executeVibeFunction(state, func, args, newValueStack);
+  }
+
+  // Handle imported TS function
+  if (typeof callee === 'object' && callee !== null && '__vibeImportedTsFunction' in callee) {
+    const funcName = (callee as { __vibeImportedTsFunction: boolean; name: string }).name;
+    // Resolve AIResultObject values to primitives for TS functions
+    const resolvedArgs = args.map(arg => resolveValue(arg));
+
+    // Check if we're in async context (variable, destructuring, or fire-and-forget)
+    if (isInAsyncContext(state)) {
+      // Schedule for non-blocking execution using shared helper
+      const newState = scheduleAsyncOperation(
+        state,
+        {
+          type: 'ts-function',
+          tsFuncDetails: {
+            funcName,
+            args: resolvedArgs,
+            location,
+          },
+        },
+        'async_ts_function_scheduled'
+      );
+      return { ...newState, valueStack: newValueStack };
+    }
+
+    // Normal blocking execution
+    return {
+      ...state,
+      valueStack: newValueStack,
+      status: 'awaiting_ts',
+      pendingImportedTsCall: { funcName, args: resolvedArgs, location },
+      executionLog: [
+        ...state.executionLog,
+        {
+          timestamp: Date.now(),
+          instructionType: 'imported_ts_call_request',
+          details: { funcName, argCount },
+        },
+      ],
+    };
+  }
+
+  // Handle imported Vibe function
+  if (typeof callee === 'object' && callee !== null && '__vibeImportedVibeFunction' in callee) {
+    const funcName = (callee as { __vibeImportedVibeFunction: boolean; name: string }).name;
+    const func = getImportedVibeFunction(state, funcName);
+
+    if (!func) {
+      throw new Error(`ReferenceError: '${funcName}' is not defined`);
+    }
+
+    // Get the module path for scope isolation
+    const modulePath = getImportedVibeFunctionModulePath(state, funcName);
+
+    // Check if we're in async context (variable, destructuring, or fire-and-forget)
+    if (isInAsyncContext(state)) {
+      return scheduleAsyncVibeFunction(state, funcName, args, newValueStack, modulePath);
+    }
+
+    return executeVibeFunction(state, func, args, newValueStack, modulePath);
+  }
+
+  // Handle tool call - tools cannot be called directly from vibe scripts
+  // They can only be used by AI models via the tools array
+  if (typeof callee === 'object' && callee !== null && '__vibeTool' in callee) {
+    const tool = callee as VibeToolValue;
+    throw new Error(
+      `TypeError: Cannot call tool '${tool.name}' directly. Tools can only be used by AI models via the tools array in model declarations.`
+    );
+  }
+
+  // Handle core function (auto-imported, available everywhere without import)
+  if (typeof callee === 'object' && callee !== null && '__vibeCoreFunction' in callee) {
+    const funcName = (callee as { __vibeCoreFunction: boolean; name: string }).name;
+    const coreFunc = getCoreFunction(funcName);
+
+    if (!coreFunc) {
+      throw new Error(`ReferenceError: Core function '${funcName}' is not defined`);
+    }
+
+    // Core functions are synchronous, execute directly
+    const result = coreFunc(...args);
+
+    return {
+      ...state,
+      valueStack: newValueStack,
+      lastResult: result,
+    };
+  }
+
+  // Handle bound method call on object (built-in methods)
+  if (typeof callee === 'object' && callee !== null && '__boundMethod' in callee) {
+    const { object, method } = callee as { __boundMethod: boolean; object: unknown; method: string };
+    const result = executeBuiltinMethod(object, method, args);
+
+    return {
+      ...state,
+      valueStack: newValueStack,
+      lastResult: result,
+    };
+  }
+
+  throw new Error('TypeError: Cannot call non-function');
+}
+
+/**
+ * Execute a built-in method on an object.
+ */
+function executeBuiltinMethod(object: unknown, method: string, args: unknown[]): unknown {
+  // Universal toString() method - works on any type
+  if (method === 'toString') {
+    if (object === null || object === undefined) {
+      return '';
+    }
+    if (typeof object === 'object') {
+      return JSON.stringify(object);
+    }
+    return String(object);
+  }
+
+  // Array methods
+  if (Array.isArray(object)) {
+    switch (method) {
+      case 'len':
+        return object.length;
+      case 'push':
+        if (args.length === 0) {
+          throw new Error('push() requires an argument');
+        }
+        object.push(args[0]);
+        return object;  // Return the array for chaining
+      case 'pop':
+        if (object.length === 0) {
+          throw new Error('Cannot pop from empty array');
+        }
+        return object.pop();  // Return the removed element
+      default:
+        throw new Error(`Unknown array method: ${method}`);
+    }
+  }
+
+  // String methods
+  if (typeof object === 'string') {
+    switch (method) {
+      case 'len':
+        return object.length;
+      default:
+        throw new Error(`Unknown string method: ${method}`);
+    }
+  }
+
+  throw new Error(`Cannot call method '${method}' on ${typeof object}`);
+}

package/src/runtime/exec/interpolation.ts

@@ -0,0 +1,312 @@
+// String interpolation execution for Vibe
+//
+// Two contexts:
+// 1. Regular strings: {var} expands to value
+// 2. Prompt strings (do/vibe): {var} is a reference (left as-is), !{var} expands
+
+import type { SourceLocation } from '../../errors';
+import type { RuntimeState, VibeValue } from '../types';
+import { resolveValue, isVibeValue } from '../types';
+import { lookupVariable } from './variables';
+import { ESCAPED_LBRACE, ESCAPED_RBRACE, ESCAPED_BANG_LBRACE, unescapeBraces } from '../../parser/visitor/helpers';
+
+// Pattern for interpolation: {var}, {obj.prop}, {arr[0]}, {arr[1:3]}, !{...}
+// Captures: [1] = optional !, [2] = path (var.prop[0] etc.)
+const INTERPOLATION_PATTERN = /(!?)\{(\w+(?:\.\w+|\[\d+\]|\[\d*:\d*\])*)\}/g;
+
+// Pattern for simple variable detection (for async checking)
+const SIMPLE_VAR_PATTERN = /(!?)\{(\w+)/g;
+
+/**
+ * Access path element types
+ */
+type AccessElement =
+  | { type: 'property'; name: string }
+  | { type: 'index'; value: number }
+  | { type: 'slice'; start: number | null; end: number | null };
+
+/**
+ * Parsed interpolation reference
+ */
+interface InterpolationRef {
+  varName: string;
+  accessPath: AccessElement[];
+  expand: boolean;  // true for !{...}, false for {...}
+  fullMatch: string;
+}
+
+/**
+ * Parse an access path like "obj.prop[0][1:3]" into structured elements
+ */
+function parseAccessPath(path: string): { varName: string; accessPath: AccessElement[] } {
+  const accessPath: AccessElement[] = [];
+
+  // Extract variable name (first identifier)
+  const varMatch = path.match(/^(\w+)/);
+  if (!varMatch) {
+    return { varName: path, accessPath: [] };
+  }
+
+  const varName = varMatch[1];
+  let remaining = path.slice(varName.length);
+
+  while (remaining.length > 0) {
+    // Property access: .propName
+    if (remaining.startsWith('.')) {
+      const propMatch = remaining.match(/^\.(\w+)/);
+      if (propMatch) {
+        accessPath.push({ type: 'property', name: propMatch[1] });
+        remaining = remaining.slice(propMatch[0].length);
+        continue;
+      }
+    }
+
+    // Index or slice access: [n] or [start:end]
+    if (remaining.startsWith('[')) {
+      // Try slice first: [start:end], [:end], [start:], [:]
+      const sliceMatch = remaining.match(/^\[(\d*):(\d*)\]/);
+      if (sliceMatch) {
+        accessPath.push({
+          type: 'slice',
+          start: sliceMatch[1] ? parseInt(sliceMatch[1], 10) : null,
+          end: sliceMatch[2] ? parseInt(sliceMatch[2], 10) : null,
+        });
+        remaining = remaining.slice(sliceMatch[0].length);
+        continue;
+      }
+
+      // Try index: [n]
+      const indexMatch = remaining.match(/^\[(\d+)\]/);
+      if (indexMatch) {
+        accessPath.push({ type: 'index', value: parseInt(indexMatch[1], 10) });
+        remaining = remaining.slice(indexMatch[0].length);
+        continue;
+      }
+    }
+
+    // Unknown syntax - stop parsing
+    break;
+  }
+
+  return { varName, accessPath };
+}
+
+/**
+ * Resolve a value following an access path
+ */
+function resolveAccessPath(value: unknown, accessPath: AccessElement[]): unknown {
+  let current = value;
+
+  for (const element of accessPath) {
+    if (current === null || current === undefined) {
+      return undefined;
+    }
+
+    switch (element.type) {
+      case 'property':
+        current = (current as Record<string, unknown>)[element.name];
+        break;
+
+      case 'index':
+        current = (current as unknown[])[element.value];
+        break;
+
+      case 'slice': {
+        const arr = current as unknown[];
+        if (!Array.isArray(arr)) {
+          return undefined;
+        }
+        const start = element.start ?? 0;
+        const end = element.end ?? arr.length;
+        current = arr.slice(start, end);
+        break;
+      }
+    }
+  }
+
+  return current;
+}
+
+/**
+ * Parse all interpolation references from a template string
+ */
+function parseInterpolations(template: string): InterpolationRef[] {
+  const refs: InterpolationRef[] = [];
+  INTERPOLATION_PATTERN.lastIndex = 0;
+
+  let match;
+  while ((match = INTERPOLATION_PATTERN.exec(template)) !== null) {
+    const [fullMatch, bang, path] = match;
+    const { varName, accessPath } = parseAccessPath(path);
+
+    refs.push({
+      varName,
+      accessPath,
+      expand: bang === '!',
+      fullMatch,
+    });
+  }
+
+  return refs;
+}
+
+/**
+ * Check for pending async variables in the template
+ */
+function getPendingAsyncIds(state: RuntimeState, template: string): string[] {
+  const pendingIds: string[] = [];
+  SIMPLE_VAR_PATTERN.lastIndex = 0;
+
+  let match;
+  while ((match = SIMPLE_VAR_PATTERN.exec(template)) !== null) {
+    const varName = match[2];
+    const found = lookupVariable(state, varName);
+
+    if (found) {
+      const variable = found.variable;
+      if (isVibeValue(variable) && variable.asyncOperationId) {
+        const opId = variable.asyncOperationId;
+        const operation = state.asyncOperations.get(opId);
+        if (operation && (operation.status === 'pending' || operation.status === 'running')) {
+          if (!pendingIds.includes(opId)) {
+            pendingIds.push(opId);
+          }
+        }
+      }
+    }
+  }
+
+  return pendingIds;
+}
+
+/**
+ * Resolve a single interpolation reference to a string value
+ */
+function resolveInterpolationToString(state: RuntimeState, ref: InterpolationRef): string {
+  const found = lookupVariable(state, ref.varName);
+
+  if (!found) {
+    // Variable not found - leave as placeholder
+    return ref.fullMatch;
+  }
+
+  // Get the raw value, resolving VibeValue if needed
+  let value = resolveValue(found.variable.value);
+
+  // Follow access path
+  if (ref.accessPath.length > 0) {
+    value = resolveAccessPath(value, ref.accessPath);
+  }
+
+  // Convert to string
+  if (value === undefined) {
+    return ref.fullMatch;
+  }
+  if (value === null) {
+    return 'null';
+  }
+  if (typeof value === 'object') {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+/**
+ * Regular string interpolation - {var} expands to value.
+ * Supports: {var}, {obj.prop}, {arr[0]}, {arr[1:3]}
+ * !{var} is an ERROR in regular strings (caught by semantic analyzer).
+ */
+export function execInterpolateRegularString(
+  state: RuntimeState,
+  template: string,
+  location?: SourceLocation
+): RuntimeState {
+  // Check for pending async variables
+  const pendingAsyncIds = getPendingAsyncIds(state, template);
+
+  if (pendingAsyncIds.length > 0) {
+    return {
+      ...state,
+      status: 'awaiting_async',
+      awaitingAsyncIds: pendingAsyncIds,
+      instructionStack: [
+        { op: 'interpolate_string', template, location: location ?? { line: 0, column: 0 } },
+        ...state.instructionStack,
+      ],
+    };
+  }
+
+  // Perform interpolation - expand all {var} patterns
+  const result = template.replace(INTERPOLATION_PATTERN, (fullMatch, bang, path) => {
+    const { varName, accessPath } = parseAccessPath(path);
+    const ref: InterpolationRef = { varName, accessPath, expand: true, fullMatch };
+    return resolveInterpolationToString(state, ref);
+  });
+
+  // Convert escape placeholders back to literal characters
+  const finalResult = unescapeBraces(result);
+
+  return { ...state, lastResult: finalResult };
+}
+
+/**
+ * Prompt string interpolation - {var} is reference (left as-is), !{var} expands.
+ * Supports: {var}, {obj.prop}, {arr[0]}, {arr[1:3]}, !{var}, !{obj.prop}, etc.
+ *
+ * Even for {var} references, we wait for async variables to resolve because:
+ * 1. The context system needs the resolved value to show the AI
+ * 2. The variable must be valid and resolved for the prompt to be meaningful
+ */
+export function execInterpolatePromptString(
+  state: RuntimeState,
+  template: string,
+  location?: SourceLocation
+): RuntimeState {
+  // Check for pending async variables in ALL interpolations (both {} and !{})
+  // For {var} references, we still need the value resolved for context
+  const pendingAsyncIds = getPendingAsyncIds(state, template);
+
+  if (pendingAsyncIds.length > 0) {
+    return {
+      ...state,
+      status: 'awaiting_async',
+      awaitingAsyncIds: pendingAsyncIds,
+      instructionStack: [
+        { op: 'interpolate_prompt_string', template, location: location ?? { line: 0, column: 0 } },
+        ...state.instructionStack,
+      ],
+    };
+  }
+
+  // Perform interpolation
+  // - {var} references: leave as-is (AI will see the literal {var})
+  // - !{var} expansions: replace with value
+  const result = template.replace(INTERPOLATION_PATTERN, (fullMatch, bang, path) => {
+    const isExpansion = bang === '!';
+
+    if (!isExpansion) {
+      // {var} reference - leave as-is for AI to see
+      return fullMatch;
+    }
+
+    // !{var} expansion - replace with value
+    const { varName, accessPath } = parseAccessPath(path);
+    const ref: InterpolationRef = { varName, accessPath, expand: true, fullMatch };
+    return resolveInterpolationToString(state, ref);
+  });
+
+  // Convert escape placeholders back to literal characters
+  const finalResult = unescapeBraces(result);
+
+  return { ...state, lastResult: finalResult };
+}
+
+/**
+ * Clear prompt context flag
+ */
+export function execClearPromptContext(state: RuntimeState): RuntimeState {
+  return {
+    ...state,
+    inPromptContext: false,
+  };
+}