@vibe-lang/runtime 0.2.5

package/src/index.ts

@@ -0,0 +1,358 @@
+// Version (updated by publish script)
+export const VERSION = '0.2.4';
+
+// Re-export public API
+export { VibeLexer, tokenize, allTokens } from './lexer';
+export { vibeParser } from './parser';
+export { parse } from './parser/parse';
+export { analyze } from './semantic';
+export { Runtime, RuntimeStatus } from './runtime';
+export type { RuntimeState, AIProvider } from './runtime';
+export * as AST from './ast';
+export * from './errors';
+
+import { parse } from './parser/parse';
+import { analyze } from './semantic';
+import { Runtime, AIProvider, createRealAIProvider } from './runtime';
+import { readdirSync, rmSync, statSync } from 'fs';
+import { join, dirname } from 'path';
+
+// Clean up orphaned temp directories from previous failed updates (Windows)
+function cleanupOrphanedDirs(): void {
+  if (process.platform !== 'win32') return;
+
+  try {
+    // Find @vibe-lang in the executable path (works with nvm, volta, standard installs)
+    const execPath = process.execPath;
+    const marker = '@vibe-lang';
+    const markerIndex = execPath.indexOf(marker);
+    if (markerIndex === -1) return;
+
+    // Construct path to node_modules/@vibe-lang
+    const vibeLangDir = execPath.substring(0, markerIndex + marker.length);
+
+    const entries = readdirSync(vibeLangDir);
+
+    // Look for orphaned .vibe-* temp directories
+    for (const entry of entries) {
+      if (entry.startsWith('.vibe-')) {
+        const fullPath = join(vibeLangDir, entry);
+        try {
+          const stat = statSync(fullPath);
+          // Only delete if it's a directory and older than 1 minute
+          if (stat.isDirectory() && Date.now() - stat.mtimeMs > 60000) {
+            rmSync(fullPath, { recursive: true, force: true });
+          }
+        } catch {
+          // Ignore errors - directory may still be locked
+        }
+      }
+    }
+  } catch {
+    // Silently ignore cleanup errors
+  }
+}
+
+// Simple mock AI provider for testing
+class MockAIProvider implements AIProvider {
+  async execute(prompt: string) {
+    return { value: `[AI Response to: ${prompt}]` };
+  }
+
+  async generateCode(prompt: string) {
+    return { value: `// Generated code for: ${prompt}\nlet result = "generated"` };
+  }
+
+  async askUser(prompt: string): Promise<string> {
+    return `[User response to: ${prompt}]`;
+  }
+}
+
+// Options for running a vibe program
+export interface RunVibeOptions {
+  aiProvider?: AIProvider;
+  file?: string;
+}
+
+// Main function to run a vibe program
+export async function runVibe(source: string, options?: RunVibeOptions): Promise<unknown> {
+  // 1. Parse
+  const ast = parse(source, { file: options?.file });
+
+  // 2. Semantic analysis
+  const errors = analyze(ast, source);
+  if (errors.length > 0) {
+    throw errors[0];
+  }
+
+  // 3. Runtime
+  const runtime = new Runtime(ast, options?.aiProvider ?? new MockAIProvider(), { basePath: options?.file });
+  return runtime.run();
+}
+
+// CLI entry point
+async function main(): Promise<void> {
+  // Clean up orphaned temp directories from previous updates
+  cleanupOrphanedDirs();
+
+  const args = Bun.argv.slice(2);
+
+  // Handle upgrade/update command
+  if (args[0] === 'upgrade' || args[0] === 'update') {
+    const targetVersion = args[1] || 'latest';
+    const packageSpec = `@vibe-lang/vibe@${targetVersion}`;
+    console.log(`Upgrading vibe to ${targetVersion}...`);
+
+    const proc = Bun.spawn(['npm', 'install', '-g', packageSpec], {
+      stdout: 'pipe',
+      stderr: 'pipe',
+    });
+
+    // Stream stdout directly
+    (async () => {
+      const reader = proc.stdout.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        process.stdout.write(value);
+      }
+    })();
+
+    // Filter stderr to suppress cleanup warnings on Windows
+    (async () => {
+      const reader = proc.stderr.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+        for (const line of lines) {
+          // Skip npm cleanup warnings (Windows file locking issue)
+          if (line.includes('npm warn cleanup')) continue;
+          if (line.trim()) {
+            process.stderr.write(line + '\n');
+          }
+        }
+      }
+
+      // Handle remaining buffer
+      if (buffer.trim() && !buffer.includes('npm warn cleanup')) {
+        process.stderr.write(buffer + '\n');
+      }
+    })();
+
+    const exitCode = await proc.exited;
+
+    if (exitCode === 0) {
+      console.log('vibe upgraded successfully!');
+    }
+
+    process.exit(exitCode);
+  }
+
+  // Handle version flag
+  if (args.includes('--version') || args.includes('-v')) {
+    console.log(`vibe ${VERSION}`);
+    return;
+  }
+
+  // Parse flags
+  const verbose = args.includes('--verbose');
+  const inspect = args.includes('--inspect');
+  const inspectBrk = args.includes('--inspect-brk');
+  const debugMode = inspect || inspectBrk;
+  const stopOnEntry = inspectBrk;
+
+  // Parse --inspect-port=PORT option
+  let debugPort = 9229; // Default debug port
+  const portArg = args.find(arg => arg.startsWith('--inspect-port='));
+  if (portArg) {
+    debugPort = parseInt(portArg.split('=')[1], 10);
+  }
+
+  // Parse --log-dir=PATH option
+  let logDir: string | undefined;
+  const logDirArg = args.find(arg => arg.startsWith('--log-dir='));
+  if (logDirArg) {
+    logDir = logDirArg.split('=')[1];
+  }
+
+  // Parse --max-parallel=N option (for async operations)
+  let maxParallel = 4; // Default
+  const maxParallelArg = args.find(arg => arg.startsWith('--max-parallel='));
+  if (maxParallelArg) {
+    const parsed = parseInt(maxParallelArg.split('=')[1], 10);
+    if (!isNaN(parsed) && parsed > 0) {
+      maxParallel = parsed;
+    }
+  }
+
+  const fileArgs = args.filter(arg => !arg.startsWith('--'));
+
+  if (fileArgs.length === 0) {
+    console.log('Vibe - AI Agent Language');
+    console.log('Usage: vibe [command] [options] <file.vibe>');
+    console.log('');
+    console.log('Commands:');
+    console.log('  upgrade [version]   Update vibe (default: latest)');
+    console.log('');
+    console.log('Options:');
+    console.log('  --verbose             Enable verbose JSONL logging (console + file)');
+    console.log('  --log-dir=PATH        Directory for logs (default: .vibe-logs)');
+    console.log('  --max-parallel=N      Max concurrent async operations (default: 4)');
+    console.log('  --inspect             Start with debugger server');
+    console.log('  --inspect-brk         Start with debugger, break on entry');
+    console.log('  --inspect-port=PORT   Debug server port (default: 9229)');
+    console.log('  -v, --version         Show version number');
+    console.log('');
+    console.log('Example program:');
+    console.log('  let x = "hello"');
+    console.log('  let y = vibe "what is 2 + 2?"');
+    console.log('  function greet(name) {');
+    console.log('    return "Hello, {name}!"');
+    console.log('  }');
+    return;
+  }
+
+  const filePath = fileArgs[0];
+  const file = Bun.file(filePath);
+
+  if (!(await file.exists())) {
+    console.error(`Error: File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  const source = await file.text();
+
+  try {
+    // Parse and analyze
+    const ast = parse(source, { file: filePath });
+    const errors = analyze(ast, source);
+    if (errors.length > 0) {
+      throw errors[0];
+    }
+
+    if (debugMode) {
+      // Run in debug mode
+      await runDebugMode(ast, filePath, debugPort, stopOnEntry, verbose, logDir);
+    } else {
+      // Normal execution
+      const runtime: Runtime = new Runtime(
+        ast,
+        createRealAIProvider(() => runtime.getState()),
+        {
+          basePath: filePath,
+          verbose,
+          logDir,
+          maxParallel,
+        }
+      );
+
+      const result = await runtime.run();
+
+      // Show log paths if verbose logging was enabled
+      if (verbose) {
+        const mainLogPath = runtime.getMainLogPath();
+        const contextDir = runtime.getContextDir();
+        if (mainLogPath) {
+          console.error(`[Verbose] Logs written to: ${mainLogPath}`);
+        }
+        if (contextDir) {
+          console.error(`[Verbose] Context files in: ${contextDir}`);
+        }
+      }
+
+      if (result !== null && result !== undefined) {
+        console.log('Result:', result);
+      }
+    }
+  } catch (error) {
+    console.error('Error:', error instanceof Error ? error.message : error);
+    process.exit(1);
+  }
+}
+
+// Debug mode execution
+async function runDebugMode(
+  ast: AST.Program,
+  filePath: string,
+  port: number,
+  stopOnEntry: boolean,
+  verbose?: boolean,
+  logDir?: string
+): Promise<void> {
+  // Import debug modules
+  const { createDebugState, runWithDebug, getCurrentLocation } = await import('./debug');
+  const { startDebugServer, sendEvent, stopDebugServer } = await import('./debug/server');
+  const { createInitialState } = await import('./runtime/state');
+  const { loadImports } = await import('./runtime/modules');
+  const { createRealAIProvider } = await import('./runtime/ai-provider');
+
+  // Create initial state
+  // Note: verbose logging in debug mode is limited for now
+  let runtimeState = createInitialState(ast);
+
+  // Load imports
+  runtimeState = await loadImports(runtimeState, filePath);
+
+  // Create debug state
+  const debugState = createDebugState({ stopOnEntry });
+
+  // Create AI provider that uses the current state
+  const aiProvider = createRealAIProvider(() => runtimeState);
+
+  console.error(`[Debug] Starting debug server on port ${port}...`);
+  console.error(`[Debug] Waiting for debugger to attach...`);
+
+  // Start server and wait for connection
+  await startDebugServer(port, runtimeState, debugState, aiProvider);
+
+  console.error(`[Debug] Debugger attached, starting execution...`);
+
+  // If stop on entry, send stopped event
+  if (stopOnEntry) {
+    const location = getCurrentLocation(runtimeState);
+    if (location) {
+      sendEvent({
+        type: 'event',
+        event: 'stopped',
+        body: {
+          reason: 'entry',
+          location,
+          threadId: 1,
+          allThreadsStopped: true,
+        },
+      });
+    }
+  } else {
+    // Run until first breakpoint or completion
+    const result = await runWithDebug(
+      runtimeState,
+      debugState,
+      aiProvider,
+      sendEvent
+    );
+    runtimeState = result.runtimeState;
+  }
+
+  // Keep process alive while debugging
+  // The server will exit on disconnect
+  await new Promise<void>((resolve) => {
+    process.on('SIGINT', () => {
+      console.error('\n[Debug] Interrupted, shutting down...');
+      stopDebugServer();
+      resolve();
+    });
+  });
+}
+
+// Run if executed directly
+if (import.meta.main) {
+  main();
+}

package/src/lexer/index.ts

@@ -0,0 +1,348 @@
+import { createToken, Lexer, ITokenConfig } from 'chevrotain';
+import { LexerError } from '../errors';
+
+// Helper to create tokens
+function token(config: ITokenConfig) {
+  return createToken(config);
+}
+
+// ============================================================================
+// Whitespace & Comments (skipped)
+// ============================================================================
+
+export const WhiteSpace = token({
+  name: 'WhiteSpace',
+  pattern: /\s+/,
+  group: Lexer.SKIPPED,
+});
+
+export const LineComment = token({
+  name: 'LineComment',
+  pattern: /\/\/[^\n]*/,
+  group: Lexer.SKIPPED,
+});
+
+export const BlockComment = token({
+  name: 'BlockComment',
+  pattern: /\/\*[\s\S]*?\*\//,
+  group: Lexer.SKIPPED,
+});
+
+// ============================================================================
+// Keywords (must come before Identifier)
+// ============================================================================
+
+// Identifier must be defined first for longer_alt references
+export const Identifier = token({
+  name: 'Identifier',
+  pattern: /[a-zA-Z_][a-zA-Z0-9_]*/,
+});
+
+export const Let = token({ name: 'Let', pattern: /let/, longer_alt: Identifier });
+export const Const = token({ name: 'Const', pattern: /const/, longer_alt: Identifier });
+export const Vibe = token({ name: 'Vibe', pattern: /vibe/, longer_alt: Identifier });
+export const Do = token({ name: 'Do', pattern: /do/, longer_alt: Identifier });
+export const Function = token({ name: 'Function', pattern: /function/, longer_alt: Identifier });
+export const Tool = token({ name: 'Tool', pattern: /tool/, longer_alt: Identifier });
+export const Return = token({ name: 'Return', pattern: /return/, longer_alt: Identifier });
+export const Break = token({ name: 'Break', pattern: /break/, longer_alt: Identifier });
+export const If = token({ name: 'If', pattern: /if/, longer_alt: Identifier });
+export const Else = token({ name: 'Else', pattern: /else/, longer_alt: Identifier });
+export const While = token({ name: 'While', pattern: /while/, longer_alt: Identifier });
+export const True = token({ name: 'True', pattern: /true/, longer_alt: Identifier });
+export const False = token({ name: 'False', pattern: /false/, longer_alt: Identifier });
+export const Null = token({ name: 'Null', pattern: /null/, longer_alt: Identifier });
+export const Model = token({ name: 'Model', pattern: /model/, longer_alt: Identifier });
+export const Default = token({ name: 'Default', pattern: /default/, longer_alt: Identifier });
+export const Local = token({ name: 'Local', pattern: /local/, longer_alt: Identifier });
+export const Import = token({ name: 'Import', pattern: /import/, longer_alt: Identifier });
+export const Export = token({ name: 'Export', pattern: /export/, longer_alt: Identifier });
+export const From = token({ name: 'From', pattern: /from/, longer_alt: Identifier });
+export const Private = token({ name: 'Private', pattern: /private/, longer_alt: Identifier });
+export const Async = token({ name: 'Async', pattern: /async/, longer_alt: Identifier });
+
+// TsBlock pattern function: Captures entire ts(params) { body }
+// Defined separately to avoid initialization issues
+function matchTsBlock(text: string, startOffset: number): RegExpExecArray | null {
+  // Must start with 'ts'
+  if (text.slice(startOffset, startOffset + 2) !== 'ts') return null;
+
+  // Check it's not part of a longer identifier
+  const nextChar = text[startOffset + 2];
+  if (nextChar && /[a-zA-Z0-9_]/.test(nextChar)) return null;
+
+  let i = startOffset + 2;
+
+  // Skip whitespace
+  while (i < text.length && /\s/.test(text[i])) i++;
+
+  // Must have '('
+  if (text[i] !== '(') return null;
+  i++;
+
+  // Find matching ')'
+  let parenDepth = 1;
+  while (i < text.length && parenDepth > 0) {
+    if (text[i] === '(') parenDepth++;
+    else if (text[i] === ')') parenDepth--;
+    i++;
+  }
+  if (parenDepth !== 0) return null;
+
+  // Skip whitespace
+  while (i < text.length && /\s/.test(text[i])) i++;
+
+  // Must have '{'
+  if (text[i] !== '{') return null;
+  i++;
+
+  // Find matching '}' with balanced brace counting
+  // Handle strings and comments to avoid false matches
+  let braceDepth = 1;
+  while (i < text.length && braceDepth > 0) {
+    const char = text[i];
+
+    // Handle string literals
+    if (char === '"' || char === "'") {
+      const quote = char;
+      i++;
+      while (i < text.length && text[i] !== quote) {
+        if (text[i] === '\\') i++; // Skip escaped char
+        i++;
+      }
+    }
+    // Handle template literals
+    else if (char === '`') {
+      i++;
+      while (i < text.length && text[i] !== '`') {
+        if (text[i] === '\\') i++;
+        i++;
+      }
+    }
+    // Handle line comments
+    else if (char === '/' && text[i + 1] === '/') {
+      while (i < text.length && text[i] !== '\n') i++;
+    }
+    // Handle block comments
+    else if (char === '/' && text[i + 1] === '*') {
+      i += 2;
+      while (i < text.length - 1 && !(text[i] === '*' && text[i + 1] === '/')) i++;
+      i++; // Skip the '/'
+    }
+    // Handle braces
+    else if (char === '{') braceDepth++;
+    else if (char === '}') braceDepth--;
+
+    i++;
+  }
+
+  if (braceDepth !== 0) return null;
+
+  // Create a fake RegExpExecArray
+  const match = text.slice(startOffset, i);
+  const result = [match] as RegExpExecArray;
+  result.index = startOffset;
+  result.input = text;
+  return result;
+}
+
+// TsBlock: Captures entire ts(params) { body } as a single token
+export const TsBlock = createToken({
+  name: 'TsBlock',
+  pattern: matchTsBlock,
+  line_breaks: true,
+  start_chars_hint: ['t'],  // TsBlock always starts with 't' (from 'ts')
+});
+
+// Type keywords
+export const TextType = token({ name: 'TextType', pattern: /text/, longer_alt: Identifier });
+export const JsonType = token({ name: 'JsonType', pattern: /json/, longer_alt: Identifier });
+export const PromptType = token({ name: 'PromptType', pattern: /prompt/, longer_alt: Identifier });
+export const BooleanType = token({ name: 'BooleanType', pattern: /boolean/, longer_alt: Identifier });
+export const NumberType = token({ name: 'NumberType', pattern: /number/, longer_alt: Identifier });
+
+// Loop keywords
+export const For = token({ name: 'For', pattern: /for/, longer_alt: Identifier });
+export const In = token({ name: 'In', pattern: /in/, longer_alt: Identifier });
+
+// Context mode keywords
+export const Forget = token({ name: 'Forget', pattern: /forget/, longer_alt: Identifier });
+export const Verbose = token({ name: 'Verbose', pattern: /verbose/, longer_alt: Identifier });
+export const Compress = token({ name: 'Compress', pattern: /compress/, longer_alt: Identifier });
+
+// Tool metadata decorators
+export const AtDescription = token({ name: 'AtDescription', pattern: /@description/ });
+export const AtParam = token({ name: 'AtParam', pattern: /@param/ });
+
+// Logical operators (word-based)
+export const And = token({ name: 'And', pattern: /and/, longer_alt: Identifier });
+export const Or = token({ name: 'Or', pattern: /or/, longer_alt: Identifier });
+export const Not = token({ name: 'Not', pattern: /not/, longer_alt: Identifier });
+
+// ============================================================================
+// Literals
+// ============================================================================
+
+export const StringLiteral = token({
+  name: 'StringLiteral',
+  pattern: /"([^"\\]|\\.)*"|'([^'\\]|\\.)*'/,
+});
+
+export const TemplateLiteral = token({
+  name: 'TemplateLiteral',
+  pattern: /`(?:[^`\\]|\\.|\r?\n)*`/,
+});
+
+// Number literals: integers and decimals (optional leading minus)
+export const NumberLiteral = token({
+  name: 'NumberLiteral',
+  pattern: /-?[0-9]+(\.[0-9]+)?/,
+});
+
+// ============================================================================
+// Operators
+// ============================================================================
+
+// Comparison (multi-char must come before single-char)
+export const EqualEqual = token({ name: 'EqualEqual', pattern: /==/ });
+export const NotEqual = token({ name: 'NotEqual', pattern: /!=/ });
+export const LessEqual = token({ name: 'LessEqual', pattern: /<=/ });
+export const GreaterEqual = token({ name: 'GreaterEqual', pattern: />=/ });
+export const LessThan = token({ name: 'LessThan', pattern: /</ });
+export const GreaterThan = token({ name: 'GreaterThan', pattern: />/ });
+
+// Assignment (after == to avoid conflict)
+export const Equals = token({ name: 'Equals', pattern: /=/ });
+
+// Arithmetic
+export const Plus = token({ name: 'Plus', pattern: /\+/ });
+export const Minus = token({ name: 'Minus', pattern: /-/ });
+export const Star = token({ name: 'Star', pattern: /\*/ });
+export const Slash = token({ name: 'Slash', pattern: /\// });
+export const Percent = token({ name: 'Percent', pattern: /%/ });
+
+// ============================================================================
+// Delimiters
+// ============================================================================
+
+export const LParen = token({ name: 'LParen', pattern: /\(/ });
+export const RParen = token({ name: 'RParen', pattern: /\)/ });
+export const LBrace = token({ name: 'LBrace', pattern: /\{/ });
+export const RBrace = token({ name: 'RBrace', pattern: /\}/ });
+export const LBracket = token({ name: 'LBracket', pattern: /\[/ });
+export const RBracket = token({ name: 'RBracket', pattern: /\]/ });
+export const Comma = token({ name: 'Comma', pattern: /,/ });
+export const Colon = token({ name: 'Colon', pattern: /:/ });
+export const DotDot = token({ name: 'DotDot', pattern: /\.\./ });
+export const Dot = token({ name: 'Dot', pattern: /\./ });  // Must be after DotDot
+
+// ============================================================================
+// All tokens in order (order matters for matching!)
+// ============================================================================
+
+export const allTokens = [
+  // Whitespace & comments first
+  WhiteSpace,
+  LineComment,
+  BlockComment,
+
+  // Keywords before Identifier
+  Let,
+  Const,
+  Vibe,
+  Do,
+  Function,
+  Tool,
+  Return,
+  Break,
+  If,
+  Else,
+  While,
+  // Context mode keywords (Forget must come before For since 'forget' starts with 'for')
+  Forget,
+  Verbose,
+  Compress,
+  // Tool metadata decorators (must come before For/other identifiers)
+  AtDescription,
+  AtParam,
+  For,
+  In,
+  And,
+  Or,
+  Not,
+  True,
+  False,
+  Null,
+  Model,
+  Default,
+  Local,
+  Import,
+  Export,
+  From,
+  Private,
+  Async,
+  TsBlock,  // Must be before Identifier - captures entire ts(...) { ... }
+  TextType,
+  JsonType,
+  PromptType,
+  BooleanType,
+  NumberType,
+
+  // Literals
+  StringLiteral,
+  TemplateLiteral,
+  NumberLiteral,
+
+  // Identifier after keywords
+  Identifier,
+
+  // Operators (multi-char before single-char)
+  EqualEqual,
+  NotEqual,
+  LessEqual,
+  GreaterEqual,
+  LessThan,
+  GreaterThan,
+  Equals,
+  Plus,
+  Minus,
+  Star,
+  Slash,
+  Percent,
+
+  // Delimiters
+  LParen,
+  RParen,
+  LBrace,
+  RBrace,
+  LBracket,
+  RBracket,
+  Comma,
+  Colon,
+  DotDot,
+  Dot,
+];
+
+// ============================================================================
+// Create the Lexer instance
+// ============================================================================
+
+export const VibeLexer = new Lexer(allTokens, {
+  ensureOptimizations: true,
+});
+
+// Helper function to tokenize source code
+export function tokenize(source: string) {
+  const result = VibeLexer.tokenize(source);
+
+  if (result.errors.length > 0) {
+    const error = result.errors[0];
+    throw new LexerError(
+      error.message,
+      { line: error.line ?? 1, column: error.column ?? 1 },
+      source
+    );
+  }
+
+  return result.tokens;
+}

package/src/lexer.ts

@@ -0,0 +1,2 @@
+// Re-export from new location for backwards compatibility
+export * from './lexer/index';