@vibe-lang/runtime 0.2.5

package/src/runtime/state.ts

@@ -0,0 +1,489 @@
+import * as AST from '../ast';
+import type { RuntimeState, AIOperation, AIInteraction, StackFrame, FrameEntry, PromptToolCall, ToolCallRecord, VibeValue } from './types';
+import { createVibeValue } from './types';
+import type { ToolRoundResult } from './ai/tool-loop';
+
+// Options for creating initial state
+export interface InitialStateOptions {
+  logAiInteractions?: boolean;
+  rootDir?: string;       // Root directory for file operation sandboxing (defaults to cwd)
+  maxParallel?: number;   // Max concurrent async operations (default: 4)
+}
+
+// Create initial runtime state from a program AST
+export function createInitialState(
+  program: AST.Program,
+  options?: InitialStateOptions
+): RuntimeState {
+  // Collect function declarations
+  const functions: Record<string, AST.FunctionDeclaration> = {};
+  for (const stmt of program.body) {
+    if (stmt.type === 'FunctionDeclaration') {
+      functions[stmt.name] = stmt;
+    }
+  }
+
+  // Create initial instruction stack with all top-level statements
+  // We pop from the front, so first statement should be at index 0
+  const instructionStack = program.body
+    .map((stmt) => ({ op: 'exec_statement' as const, stmt, location: stmt.location }));
+
+  return {
+    status: 'running',
+    program,
+    functions,
+    tsModules: {},
+    vibeModules: {},
+    importedNames: {},
+    callStack: [createFrame('<entry>')],
+    instructionStack,
+    valueStack: [],
+    lastResult: null,
+    lastResultSource: null,
+    aiHistory: [],
+    executionLog: [],
+    logAiInteractions: options?.logAiInteractions ?? false,
+    aiInteractions: [],
+    localContext: [],
+    globalContext: [],
+    pendingAI: null,
+    pendingCompress: null,
+    pendingTS: null,
+    pendingImportedTsCall: null,
+    pendingToolCall: null,
+    pendingDestructuring: null,
+    expectedFields: null,
+    lastUsedModel: null,
+    rootDir: options?.rootDir ?? process.cwd(),
+    error: null,
+    errorObject: null,
+
+    // Async execution tracking
+    asyncOperations: new Map(),
+    pendingAsyncIds: new Set(),
+    asyncVarToOpId: new Map(),
+    asyncWaves: [],
+    currentWaveId: 0,
+    maxParallel: options?.maxParallel ?? 4,
+    nextAsyncId: 1,
+    awaitingAsyncIds: [],
+
+    // Async declaration context (set when inside async let/const)
+    currentAsyncVarName: null,
+    currentAsyncIsConst: false,
+    currentAsyncType: null,
+    currentAsyncIsPrivate: false,
+    currentAsyncIsDestructure: false,
+    currentAsyncIsFireAndForget: false,
+
+    // Async function isolation
+    isInAsyncIsolation: false,
+
+    // Scheduled async operations
+    pendingAsyncStarts: [],
+
+    // String interpolation context (for prompt strings in do/vibe)
+    inPromptContext: false,
+  };
+}
+
+// Create a new stack frame
+export function createFrame(name: string, parentFrameIndex: number | null = null): StackFrame {
+  return {
+    name,
+    locals: {},
+    parentFrameIndex,
+    orderedEntries: [],
+  };
+}
+
+// Resume execution after AI response
+export function resumeWithAIResponse(
+  state: RuntimeState,
+  response: unknown,
+  interaction?: AIInteraction,
+  toolRounds?: ToolRoundResult[]
+): RuntimeState {
+  if (state.status !== 'awaiting_ai' || !state.pendingAI) {
+    throw new Error('Cannot resume: not awaiting AI response');
+  }
+
+  const responseStr = typeof response === 'string' ? response : JSON.stringify(response);
+  const pendingAI = state.pendingAI;
+
+  const aiOp: AIOperation = {
+    type: pendingAI.type,
+    prompt: pendingAI.prompt,
+    response: responseStr,
+    timestamp: Date.now(),
+  };
+
+  // Add interaction to log if provided and logging is enabled
+  const aiInteractions = state.logAiInteractions && interaction
+    ? [...state.aiInteractions, interaction]
+    : state.aiInteractions;
+
+  // Build ordered entries with prompt containing embedded tool calls
+  const frame = state.callStack[state.callStack.length - 1];
+
+  // Convert tool rounds to PromptToolCall format (embedded in prompt entry for context)
+  const promptToolCalls: PromptToolCall[] = (toolRounds ?? []).flatMap((round) =>
+    round.toolCalls.map((call, index) => {
+      const result = round.results[index];
+      const toolCall: PromptToolCall = {
+        toolName: call.toolName,
+        args: call.args,
+      };
+      if (result?.error) {
+        toolCall.error = result.error;
+      } else if (result?.result !== undefined) {
+        toolCall.result = result.result;
+      }
+      return toolCall;
+    })
+  );
+
+  // Build ToolCallRecord array for VibeValue (all rounds accumulated)
+  const toolCallRecords: ToolCallRecord[] = (toolRounds ?? []).flatMap((round) =>
+    round.toolCalls.map((call, index) => {
+      const result = round.results[index];
+      const error = result?.error;
+      return {
+        toolName: call.toolName,
+        args: call.args,
+        result: error ? null : String(result?.result ?? ''),
+        err: !!error,
+        errDetails: error ? { message: error } : null,
+        duration: result?.duration ?? 0,
+      };
+    })
+  );
+
+  // Create VibeValue with final response value and all tool calls
+  const aiResultValue: VibeValue = createVibeValue(response, {
+    source: 'ai',
+    toolCalls: toolCallRecords,
+  });
+
+  // Create prompt entry with embedded tool calls (order: prompt → tools → response)
+  // Note: promptEntry.response stores raw value for context display
+  const promptEntry: FrameEntry = {
+    kind: 'prompt' as const,
+    aiType: pendingAI.type,
+    prompt: pendingAI.prompt,
+    toolCalls: promptToolCalls.length > 0 ? promptToolCalls : undefined,
+    response,  // Include response for context history
+  };
+
+  const newOrderedEntries = [
+    ...frame.orderedEntries,
+    promptEntry,
+  ];
+  const updatedCallStack = [
+    ...state.callStack.slice(0, -1),
+    { ...frame, orderedEntries: newOrderedEntries },
+  ];
+
+  return {
+    ...state,
+    status: 'running',
+    lastResult: aiResultValue,  // Store VibeValue with response and toolCalls
+    lastResultSource: 'ai',
+    callStack: updatedCallStack,
+    aiHistory: [...state.aiHistory, aiOp],
+    aiInteractions,
+    pendingAI: null,
+    executionLog: [
+      ...state.executionLog,
+      {
+        timestamp: Date.now(),
+        instructionType: `ai_${pendingAI.type}_response`,
+        details: { prompt: pendingAI.prompt, toolRounds: toolRounds?.length ?? 0 },
+        result: responseStr,
+      },
+    ],
+  };
+}
+
+// Resume execution after user input
+export function resumeWithUserInput(state: RuntimeState, input: string): RuntimeState {
+  if (state.status !== 'awaiting_user' || !state.pendingAI) {
+    throw new Error('Cannot resume: not awaiting user input');
+  }
+
+  const pendingAI = state.pendingAI;
+
+  const aiOp: AIOperation = {
+    type: 'ask',
+    prompt: pendingAI.prompt,
+    response: input,
+    timestamp: Date.now(),
+  };
+
+  // Add the completed prompt to orderedEntries in current frame (with response for history)
+  const frame = state.callStack[state.callStack.length - 1];
+  const newOrderedEntries = [
+    ...frame.orderedEntries,
+    {
+      kind: 'prompt' as const,
+      aiType: 'ask' as const,
+      prompt: pendingAI.prompt,
+      response: input,  // Include user input for context history
+    }
+  ];
+  const updatedCallStack = [
+    ...state.callStack.slice(0, -1),
+    { ...frame, orderedEntries: newOrderedEntries },
+  ];
+
+  return {
+    ...state,
+    status: 'running',
+    lastResult: input,
+    lastResultSource: 'user',
+    callStack: updatedCallStack,
+    aiHistory: [...state.aiHistory, aiOp],
+    pendingAI: null,
+    executionLog: [
+      ...state.executionLog,
+      {
+        timestamp: Date.now(),
+        instructionType: 'user_input_response',
+        details: { prompt: pendingAI.prompt },
+        result: input,
+      },
+    ],
+  };
+}
+
+// Resume execution after TypeScript evaluation (inline ts block)
+export function resumeWithTsResult(state: RuntimeState, result: unknown): RuntimeState {
+  if (state.status !== 'awaiting_ts' || !state.pendingTS) {
+    throw new Error('Cannot resume: not awaiting TypeScript result');
+  }
+
+  // Normalize undefined to null for Vibe's single null concept
+  const normalizedResult = result === undefined ? null : result;
+
+  return {
+    ...state,
+    status: 'running',
+    lastResult: normalizedResult,
+    pendingTS: null,
+    executionLog: [
+      ...state.executionLog,
+      {
+        timestamp: Date.now(),
+        instructionType: 'ts_eval_result',
+        details: { params: state.pendingTS.params },
+        result: normalizedResult,
+      },
+    ],
+  };
+}
+
+// Resume execution after imported TS function call
+export function resumeWithImportedTsResult(state: RuntimeState, result: unknown): RuntimeState {
+  if (state.status !== 'awaiting_ts' || !state.pendingImportedTsCall) {
+    throw new Error('Cannot resume: not awaiting imported TS function result');
+  }
+
+  // Normalize undefined to null for Vibe's single null concept
+  const normalizedResult = result === undefined ? null : result;
+
+  return {
+    ...state,
+    status: 'running',
+    lastResult: normalizedResult,
+    pendingImportedTsCall: null,
+    executionLog: [
+      ...state.executionLog,
+      {
+        timestamp: Date.now(),
+        instructionType: 'imported_ts_call_result',
+        details: { funcName: state.pendingImportedTsCall.funcName },
+        result: normalizedResult,
+      },
+    ],
+  };
+}
+
+// Resume execution after compress AI summarization
+export function resumeWithCompressResult(state: RuntimeState, summary: string): RuntimeState {
+  if (state.status !== 'awaiting_compress' || !state.pendingCompress) {
+    throw new Error('Cannot resume: not awaiting compress result');
+  }
+
+  const { entryIndex, scopeType, label } = state.pendingCompress;
+  const frame = state.callStack[state.callStack.length - 1];
+
+  // Replace loop entries with summary, keeping scope markers
+  const newOrderedEntries: FrameEntry[] = [
+    ...frame.orderedEntries.slice(0, entryIndex),
+    { kind: 'scope-enter', scopeType, label },
+    { kind: 'summary', text: summary },
+    { kind: 'scope-exit', scopeType, label },
+  ];
+
+  return {
+    ...state,
+    status: 'running',
+    pendingCompress: null,
+    callStack: [
+      ...state.callStack.slice(0, -1),
+      { ...frame, orderedEntries: newOrderedEntries },
+    ],
+    executionLog: [
+      ...state.executionLog,
+      {
+        timestamp: Date.now(),
+        instructionType: 'compress_result',
+        details: { scopeType, label, prompt: state.pendingCompress.prompt },
+        result: summary,
+      },
+    ],
+  };
+}
+
+// Resume execution after tool call
+export function resumeWithToolResult(
+  state: RuntimeState,
+  result: unknown,
+  error?: string
+): RuntimeState {
+  if (state.status !== 'awaiting_tool' || !state.pendingToolCall) {
+    throw new Error('Cannot resume: not awaiting tool result');
+  }
+
+  const pendingTool = state.pendingToolCall;
+  const finalResult = error ? { error } : result;
+
+  return {
+    ...state,
+    status: 'running',
+    lastResult: finalResult,
+    pendingToolCall: null,
+    executionLog: [
+      ...state.executionLog,
+      {
+        timestamp: Date.now(),
+        instructionType: 'tool_call_result',
+        details: {
+          toolName: pendingTool.toolName,
+          hasError: !!error,
+        },
+        result: finalResult,
+      },
+    ],
+  };
+}
+
+// Resume execution after async operations complete
+export function resumeWithAsyncResults(
+  state: RuntimeState,
+  results: Map<string, VibeValue>
+): RuntimeState {
+  if (state.status !== 'awaiting_async') {
+    throw new Error('Cannot resume: not awaiting async results');
+  }
+
+  // Update variables with their async results
+  const frame = state.callStack[state.callStack.length - 1];
+  const newLocals = { ...frame.locals };
+
+  // Track the last result for operations that need it (e.g., destructuring)
+  let lastResult: VibeValue | null = null;
+
+  for (const [opId, result] of results) {
+    const operation = state.asyncOperations.get(opId);
+    if (operation?.variableName) {
+      // Preserve existing variable properties (isConst, isPrivate, typeAnnotation)
+      // when updating with the async result
+      const existingVar = newLocals[operation.variableName];
+      newLocals[operation.variableName] = {
+        ...result,
+        isConst: existingVar?.isConst ?? result.isConst,
+        isPrivate: existingVar?.isPrivate ?? result.isPrivate,
+        typeAnnotation: existingVar?.typeAnnotation ?? result.typeAnnotation,
+      };
+    }
+    // Mark operation as no longer pending
+    state.pendingAsyncIds.delete(opId);
+    // Keep track of the result (for destructuring and other uses)
+    lastResult = result;
+  }
+
+  const updatedCallStack = [
+    ...state.callStack.slice(0, -1),
+    { ...frame, locals: newLocals },
+  ];
+
+  return {
+    ...state,
+    status: 'running',
+    // Set lastResult so instructions like destructure_assign can use it
+    lastResult: lastResult ?? state.lastResult,
+    callStack: updatedCallStack,
+    awaitingAsyncIds: [],
+    executionLog: [
+      ...state.executionLog,
+      {
+        timestamp: Date.now(),
+        instructionType: 'async_results',
+        details: { operationCount: results.size },
+      },
+    ],
+  };
+}
+
+// Pause execution manually
+export function pauseExecution(state: RuntimeState): RuntimeState {
+  if (state.status !== 'running') {
+    return state;
+  }
+  return {
+    ...state,
+    status: 'paused',
+  };
+}
+
+// Resume from manual pause
+export function resumeExecution(state: RuntimeState): RuntimeState {
+  if (state.status !== 'paused') {
+    return state;
+  }
+  return {
+    ...state,
+    status: 'running',
+  };
+}
+
+// Get current frame
+export function currentFrame(state: RuntimeState): StackFrame {
+  const frame = state.callStack[state.callStack.length - 1];
+  if (!frame) {
+    throw new Error('No active stack frame');
+  }
+  return frame;
+}
+
+// Get variable value (walks scope chain)
+export function getVariable(state: RuntimeState, name: string): unknown {
+  // Walk the scope chain
+  let frameIndex: number | null = state.callStack.length - 1;
+  while (frameIndex !== null && frameIndex >= 0) {
+    const frame: StackFrame = state.callStack[frameIndex];
+    const variable = frame.locals[name];
+    if (variable) {
+      return variable.value;
+    }
+    frameIndex = frame.parentFrameIndex;
+  }
+
+  // Check if it's a function
+  if (state.functions[name]) {
+    return { __vibeFunction: true, name };
+  }
+
+  throw new Error(`ReferenceError: '${name}' is not defined`);
+}

package/src/runtime/stdlib/core.ts

@@ -0,0 +1,45 @@
+// Core system functions - automatically available in all Vibe modules
+// These functions are injected into scope without requiring an import.
+// They CANNOT be imported via "system" or any other module path.
+
+/**
+ * Print a message to the console.
+ * @param message - The message to print
+ */
+export function print(message: unknown): void {
+  console.log(message);
+}
+
+/**
+ * Get an environment variable value.
+ * @param name - The environment variable name
+ * @param defaultValue - Default value if not set (defaults to empty string)
+ * @returns The environment variable value or default
+ */
+export function env(name: string, defaultValue: string = ''): string {
+  return process.env[name] ?? defaultValue;
+}
+
+// Registry of all core functions
+// These are checked during identifier resolution before throwing "not defined" error
+export const coreFunctions: Record<string, (...args: unknown[]) => unknown> = {
+  print,
+  env,
+};
+
+// Set of core function names for quick lookup
+export const coreFunctionNames = new Set(Object.keys(coreFunctions));
+
+/**
+ * Check if a name is a core function
+ */
+export function isCoreFunction(name: string): boolean {
+  return coreFunctionNames.has(name);
+}
+
+/**
+ * Get a core function by name
+ */
+export function getCoreFunction(name: string): ((...args: unknown[]) => unknown) | undefined {
+  return coreFunctions[name];
+}

package/src/runtime/stdlib/directory.test.ts

@@ -0,0 +1,156 @@
+// Tests for directory tools: mkdir, listDir, dirExists
+
+import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
+import { mkdir, listDir, dirExists } from './tools';
+import * as fs from 'fs';
+import * as path from 'path';
+
+const TEST_DIR = path.join(__dirname, '.test-workspace-directory');
+
+describe('mkdir tool', () => {
+  beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  test('creates single directory', async () => {
+    const dirPath = path.join(TEST_DIR, 'newdir');
+
+    const result = await mkdir.executor({ path: dirPath }, { rootDir: TEST_DIR });
+
+    expect(result).toBe(true);
+    expect(fs.existsSync(dirPath)).toBe(true);
+    expect(fs.statSync(dirPath).isDirectory()).toBe(true);
+  });
+
+  test('creates nested directories with recursive: true', async () => {
+    const dirPath = path.join(TEST_DIR, 'a', 'b', 'c');
+
+    const result = await mkdir.executor({ path: dirPath, recursive: true }, { rootDir: TEST_DIR });
+
+    expect(result).toBe(true);
+    expect(fs.existsSync(dirPath)).toBe(true);
+  });
+
+  test('fails without recursive when parent does not exist', async () => {
+    const dirPath = path.join(TEST_DIR, 'parent', 'child');
+
+    await expect(mkdir.executor({ path: dirPath }, { rootDir: TEST_DIR })).rejects.toThrow();
+  });
+
+  test('succeeds silently if directory already exists with recursive', async () => {
+    const dirPath = path.join(TEST_DIR, 'existing');
+    fs.mkdirSync(dirPath);
+
+    const result = await mkdir.executor({ path: dirPath, recursive: true }, { rootDir: TEST_DIR });
+
+    expect(result).toBe(true);
+  });
+});
+
+describe('listDir tool', () => {
+  beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  test('lists files in directory', async () => {
+    fs.writeFileSync(path.join(TEST_DIR, 'file1.txt'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'file2.txt'), '');
+
+    const result = (await listDir.executor({ path: TEST_DIR }, { rootDir: TEST_DIR })) as string[];
+
+    expect(result).toHaveLength(2);
+    expect(result).toContain('file1.txt');
+    expect(result).toContain('file2.txt');
+  });
+
+  test('lists subdirectories', async () => {
+    fs.mkdirSync(path.join(TEST_DIR, 'subdir1'));
+    fs.mkdirSync(path.join(TEST_DIR, 'subdir2'));
+    fs.writeFileSync(path.join(TEST_DIR, 'file.txt'), '');
+
+    const result = (await listDir.executor({ path: TEST_DIR }, { rootDir: TEST_DIR })) as string[];
+
+    expect(result).toHaveLength(3);
+    expect(result).toContain('subdir1');
+    expect(result).toContain('subdir2');
+    expect(result).toContain('file.txt');
+  });
+
+  test('returns empty array for empty directory', async () => {
+    const emptyDir = path.join(TEST_DIR, 'empty');
+    fs.mkdirSync(emptyDir);
+
+    const result = (await listDir.executor({ path: emptyDir }, { rootDir: TEST_DIR })) as string[];
+
+    expect(result).toEqual([]);
+  });
+
+  test('error: directory not found', async () => {
+    const nonExistent = path.join(TEST_DIR, 'nonexistent');
+
+    await expect(listDir.executor({ path: nonExistent }, { rootDir: TEST_DIR })).rejects.toThrow();
+  });
+
+  test('does not list nested contents (shallow)', async () => {
+    fs.mkdirSync(path.join(TEST_DIR, 'subdir'));
+    fs.writeFileSync(path.join(TEST_DIR, 'subdir', 'nested.txt'), '');
+    fs.writeFileSync(path.join(TEST_DIR, 'root.txt'), '');
+
+    const result = (await listDir.executor({ path: TEST_DIR }, { rootDir: TEST_DIR })) as string[];
+
+    expect(result).toHaveLength(2);
+    expect(result).toContain('subdir');
+    expect(result).toContain('root.txt');
+    expect(result).not.toContain('nested.txt');
+  });
+});
+
+describe('dirExists tool', () => {
+  beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(TEST_DIR)) {
+      fs.rmSync(TEST_DIR, { recursive: true });
+    }
+  });
+
+  test('returns true for existing directory', async () => {
+    const dirPath = path.join(TEST_DIR, 'existing');
+    fs.mkdirSync(dirPath);
+
+    const result = await dirExists.executor({ path: dirPath }, { rootDir: TEST_DIR });
+
+    expect(result).toBe(true);
+  });
+
+  test('returns false for non-existent path', async () => {
+    const dirPath = path.join(TEST_DIR, 'nonexistent');
+
+    const result = await dirExists.executor({ path: dirPath }, { rootDir: TEST_DIR });
+
+    expect(result).toBe(false);
+  });
+
+  test('returns false for file (not directory)', async () => {
+    const filePath = path.join(TEST_DIR, 'file.txt');
+    fs.writeFileSync(filePath, 'content');
+
+    const result = await dirExists.executor({ path: filePath }, { rootDir: TEST_DIR });
+
+    expect(result).toBe(false);
+  });
+});