@vibe-lang/runtime 0.2.5

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@vibe-lang/runtime",
+  "version": "0.2.5",
+  "description": "Vibe language runtime and CLI",
+  "main": "src/index.ts",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./ast": "./src/ast.ts",
+    "./parser": "./src/parser.ts",
+    "./parser/parse": "./src/parser/parse.ts",
+    "./semantic": "./src/semantic/index.ts",
+    "./errors": "./src/errors/index.ts",
+    "./runtime": "./src/runtime.ts"
+  },
+  "bin": {
+    "vibe": "src/index.ts"
+  },
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "dev": "bun --watch src/index.ts",
+    "test": "bun test src/",
+    "test:watch": "bun test --watch src/",
+    "test:integration": "bun test tests/integration/ --timeout 120000",
+    "test:all": "bun test src/ tests/integration/ --timeout 120000"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "orchestration",
+    "dsl",
+    "language"
+  ],
+  "license": "ISC",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.71.2",
+    "@google/genai": "^1.34.0",
+    "@vibe-lang/debug-core": "workspace:*",
+    "chevrotain": "^11.0.3",
+    "openai": "^6.15.0",
+    "typescript": "^5.9.3"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

package/src/ast/index.ts

@@ -0,0 +1,375 @@
+import type { SourceLocation } from '../errors';
+
+// ============================================================================
+// Base types
+// ============================================================================
+
+interface BaseNode {
+  location: SourceLocation;
+}
+
+// ============================================================================
+// AI Provider Types
+// ============================================================================
+
+/** Supported AI provider types - strictly typed */
+export type AIProviderType = 'anthropic' | 'openai' | 'google';
+
+// ============================================================================
+// Vibe Type Annotations
+// ============================================================================
+
+/** Non-nullable type annotations - when type is always required */
+export type VibeTypeRequired = 'text' | 'json' | 'boolean' | 'number' | 'prompt' | 'model' | 'text[]' | 'json[]' | 'boolean[]' | 'number[]' | 'prompt[]';
+
+/** Valid type annotations in Vibe - nullable when type is optional/inferred */
+export type VibeType = VibeTypeRequired | null;
+
+// ============================================================================
+// Context Modes
+// ============================================================================
+
+/** Compress argument - either a string literal or identifier reference */
+export type CompressArg =
+  | { kind: 'literal'; value: string }
+  | { kind: 'identifier'; name: string };
+
+/** Context mode for loops - controls what happens to context on loop exit */
+export type ContextMode =
+  | 'verbose'                    // Keep full history
+  | 'forget'                     // Discard all context from block
+  | { compress: { arg1: CompressArg | null; arg2: CompressArg | null } }; // AI summarizes
+
+// ============================================================================
+// Program
+// ============================================================================
+
+export interface Program extends BaseNode {
+  type: 'Program';
+  body: Statement[];
+}
+
+// ============================================================================
+// Statements
+// ============================================================================
+
+export type Statement =
+  | ImportDeclaration
+  | ExportDeclaration
+  | LetDeclaration
+  | ConstDeclaration
+  | DestructuringDeclaration
+  | ModelDeclaration
+  | FunctionDeclaration
+  | ToolDeclaration
+  | ReturnStatement
+  | BreakStatement
+  | IfStatement
+  | ForInStatement
+  | WhileStatement
+  | BlockStatement
+  | ExpressionStatement
+  | AsyncStatement;
+
+export interface ImportSpecifier {
+  imported: string;  // Name in the source module
+  local: string;     // Name in this module (usually same as imported)
+}
+
+export interface ImportDeclaration extends BaseNode {
+  type: 'ImportDeclaration';
+  specifiers: ImportSpecifier[];
+  source: string;              // "./utils.ts" or "./utils.vibe"
+  sourceType: 'ts' | 'vibe';   // Determined by file extension
+}
+
+export interface ExportDeclaration extends BaseNode {
+  type: 'ExportDeclaration';
+  declaration: FunctionDeclaration | LetDeclaration | ConstDeclaration | ModelDeclaration;
+}
+
+export interface LetDeclaration extends BaseNode {
+  type: 'LetDeclaration';
+  name: string;
+  typeAnnotation: VibeType;
+  initializer: Expression | null;
+  isPrivate?: boolean;  // If true, variable is hidden from AI context
+  isAsync?: boolean;    // If true, execute asynchronously in parallel
+}
+
+export interface ConstDeclaration extends BaseNode {
+  type: 'ConstDeclaration';
+  name: string;
+  typeAnnotation: VibeType;
+  initializer: Expression;
+  isPrivate?: boolean;  // If true, variable is hidden from AI context
+  isAsync?: boolean;    // If true, execute asynchronously in parallel
+}
+
+/** A single field in a destructuring pattern: name: type */
+export interface DestructuringField {
+  name: string;
+  type: VibeTypeRequired;
+  isPrivate?: boolean;  // If true, field is hidden from AI context
+}
+
+/** Destructuring declaration: const {a: text, b: number} = expr */
+export interface DestructuringDeclaration extends BaseNode {
+  type: 'DestructuringDeclaration';
+  fields: DestructuringField[];
+  initializer: Expression;
+  isConst: boolean;  // true for const, false for let
+  isAsync?: boolean; // If true, execute asynchronously in parallel
+}
+
+export interface ModelDeclaration extends BaseNode {
+  type: 'ModelDeclaration';
+  name: string;
+  config: ModelConfig;
+}
+
+export interface ModelConfig extends BaseNode {
+  type: 'ModelConfig';
+  modelName: Expression | null;
+  apiKey: Expression | null;
+  url: Expression | null;
+  provider: Expression | null;          // AIProviderType - validated in semantic analyzer
+  maxRetriesOnError: Expression | null; // Non-negative integer
+  thinkingLevel: Expression | null;     // "none" | "low" | "medium" | "high" | "max"
+  tools: Expression | null;             // Array of VibeToolValue objects
+  providedFields: string[];             // For semantic validation
+}
+
+export interface FunctionParameter {
+  name: string;
+  typeAnnotation: VibeTypeRequired;
+}
+
+export interface FunctionDeclaration extends BaseNode {
+  type: 'FunctionDeclaration';
+  name: string;
+  params: FunctionParameter[];
+  returnType: VibeType;
+  body: BlockStatement;
+  // Note: Functions always "forget" context on exit (like traditional callstack)
+}
+
+// Tool parameter with optional description for AI schema
+export interface ToolParameter {
+  name: string;
+  typeAnnotation: string;     // Vibe type or imported TS type name
+  description?: string;       // From @param decorator, for AI schema
+}
+
+// Tool declaration - function-like but with AI-callable schema
+export interface ToolDeclaration extends BaseNode {
+  type: 'ToolDeclaration';
+  name: string;
+  params: ToolParameter[];
+  returnType: VibeType;
+  description?: string;       // From @description decorator, for AI schema
+  paramDecorators?: string[]; // Names from @param decorators (for validation)
+  body: BlockStatement;
+}
+
+export interface ReturnStatement extends BaseNode {
+  type: 'ReturnStatement';
+  value: Expression | null;
+}
+
+export interface BreakStatement extends BaseNode {
+  type: 'BreakStatement';
+}
+
+export interface IfStatement extends BaseNode {
+  type: 'IfStatement';
+  condition: Expression;
+  consequent: BlockStatement;
+  alternate: BlockStatement | IfStatement | null;
+}
+
+export interface ForInStatement extends BaseNode {
+  type: 'ForInStatement';
+  variable: string;           // Loop variable name
+  iterable: Expression;       // Array, number (range), or [start, end]
+  body: BlockStatement;
+  contextMode?: ContextMode;  // What happens to context on loop exit
+}
+
+export interface WhileStatement extends BaseNode {
+  type: 'WhileStatement';
+  condition: Expression;
+  body: BlockStatement;
+  contextMode?: ContextMode;  // What happens to context on loop exit
+}
+
+export interface BlockStatement extends BaseNode {
+  type: 'BlockStatement';
+  body: Statement[];
+}
+
+export interface ExpressionStatement extends BaseNode {
+  type: 'ExpressionStatement';
+  expression: Expression;
+}
+
+/** Standalone async statement (fire-and-forget): async do/vibe/ts/function() */
+export interface AsyncStatement extends BaseNode {
+  type: 'AsyncStatement';
+  expression: VibeExpression | TsBlock | CallExpression;
+}
+
+// ============================================================================
+// Expressions
+// ============================================================================
+
+export type Expression =
+  | Identifier
+  | StringLiteral
+  | TemplateLiteral
+  | BooleanLiteral
+  | NullLiteral
+  | NumberLiteral
+  | ObjectLiteral
+  | ArrayLiteral
+  | RangeExpression
+  | BinaryExpression
+  | UnaryExpression
+  | IndexExpression
+  | SliceExpression
+  | MemberExpression
+  | AssignmentExpression
+  | CallExpression
+  | VibeExpression
+  | TsBlock;
+
+export interface Identifier extends BaseNode {
+  type: 'Identifier';
+  name: string;
+}
+
+export interface StringLiteral extends BaseNode {
+  type: 'StringLiteral';
+  value: string;
+}
+
+export interface TemplateLiteral extends BaseNode {
+  type: 'TemplateLiteral';
+  value: string;
+}
+
+export interface BooleanLiteral extends BaseNode {
+  type: 'BooleanLiteral';
+  value: boolean;
+}
+
+export interface NullLiteral extends BaseNode {
+  type: 'NullLiteral';
+}
+
+export interface NumberLiteral extends BaseNode {
+  type: 'NumberLiteral';
+  value: number;
+}
+
+export interface ObjectLiteral extends BaseNode {
+  type: 'ObjectLiteral';
+  properties: ObjectProperty[];
+}
+
+export interface ObjectProperty extends BaseNode {
+  type: 'ObjectProperty';
+  key: string;
+  value: Expression;
+}
+
+export interface ArrayLiteral extends BaseNode {
+  type: 'ArrayLiteral';
+  elements: Expression[];
+}
+
+export interface RangeExpression extends BaseNode {
+  type: 'RangeExpression';
+  start: Expression;
+  end: Expression;
+}
+
+export type BinaryOperator =
+  | '+' | '-' | '*' | '/' | '%'           // Arithmetic
+  | '==' | '!=' | '<' | '>' | '<=' | '>=' // Comparison
+  | 'and' | 'or';                          // Logical
+
+export interface BinaryExpression extends BaseNode {
+  type: 'BinaryExpression';
+  operator: BinaryOperator;
+  left: Expression;
+  right: Expression;
+}
+
+export type UnaryOperator = 'not' | '-';
+
+export interface UnaryExpression extends BaseNode {
+  type: 'UnaryExpression';
+  operator: UnaryOperator;
+  operand: Expression;
+}
+
+export interface IndexExpression extends BaseNode {
+  type: 'IndexExpression';
+  object: Expression;
+  index: Expression;
+}
+
+export interface SliceExpression extends BaseNode {
+  type: 'SliceExpression';
+  object: Expression;
+  start: Expression | null;  // null for arr[,5]
+  end: Expression | null;    // null for arr[3,]
+}
+
+export interface MemberExpression extends BaseNode {
+  type: 'MemberExpression';
+  object: Expression;
+  property: string;  // method/property name
+}
+
+export interface AssignmentExpression extends BaseNode {
+  type: 'AssignmentExpression';
+  target: Identifier;
+  value: Expression;
+}
+
+export interface CallExpression extends BaseNode {
+  type: 'CallExpression';
+  callee: Expression;
+  arguments: Expression[];
+}
+
+export interface ContextSpecifier extends BaseNode {
+  type: 'ContextSpecifier';
+  kind: 'default' | 'local' | 'variable';
+  variable?: string;
+}
+
+/** AI operation type - controls tool calling behavior */
+export type AIOperationType = 'do' | 'vibe';
+
+export interface VibeExpression extends BaseNode {
+  type: 'VibeExpression';
+  operationType: AIOperationType;  // 'do' = single call, 'vibe' = tool loop
+  prompt: Expression;
+  model: Expression | null;        // null = use lastUsedModel
+  context: ContextSpecifier | null; // null = use 'default' context
+}
+
+export interface TsBlock extends BaseNode {
+  type: 'TsBlock';
+  params: string[];  // Parameter names passed from Vibe scope
+  body: string;      // Raw TypeScript code inside braces
+}
+
+// ============================================================================
+// Node type (union of all nodes)
+// ============================================================================
+
+export type Node = Program | Statement | Expression;

package/src/ast.ts

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