@vibe-lang/runtime 0.2.8 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibe-lang/runtime",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Vibe language runtime and CLI",
   "main": "src/index.ts",
   "type": "module",

package/src/ast/index.ts

@@ -64,6 +64,7 @@ export type Statement =
   | ToolDeclaration
   | ReturnStatement
   | BreakStatement
+  | ThrowStatement
   | IfStatement
   | ForInStatement
   | WhileStatement
@@ -181,6 +182,11 @@ export interface BreakStatement extends BaseNode {
   type: 'BreakStatement';
 }
 
+export interface ThrowStatement extends BaseNode {
+  type: 'ThrowStatement';
+  message: Expression;  // The error message expression
+}
+
 export interface IfStatement extends BaseNode {
   type: 'IfStatement';
   condition: Expression;

package/src/lexer/index.ts

@@ -46,6 +46,7 @@ export const Function = token({ name: 'Function', pattern: /function/, longer_al
 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 Throw = token({ name: 'Throw', pattern: /throw/, 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 });
@@ -255,6 +256,7 @@ export const allTokens = [
   Tool,
   Return,
   Break,
+  Throw,
   If,
   Else,
   While,

package/src/parser/index.ts

@@ -38,6 +38,7 @@ class VibeParser extends CstParser {
       { ALT: () => this.SUBRULE(this.toolDeclaration) },
       { ALT: () => this.SUBRULE(this.returnStatement) },
       { ALT: () => this.SUBRULE(this.breakStatement) },
+      { ALT: () => this.SUBRULE(this.throwStatement) },
       { ALT: () => this.SUBRULE(this.ifStatement) },
       { ALT: () => this.SUBRULE(this.forInStatement) },
       { ALT: () => this.SUBRULE(this.whileStatement) },
@@ -316,6 +317,10 @@ class VibeParser extends CstParser {
       this.CONSUME(T.Comma);
       this.SUBRULE2(this.property);
     });
+    // Allow trailing comma
+    this.OPTION(() => {
+      this.CONSUME2(T.Comma);
+    });
   });
 
   private property = this.RULE('property', () => {
@@ -440,6 +445,11 @@ class VibeParser extends CstParser {
     this.CONSUME(T.Break);
   });
 
+  private throwStatement = this.RULE('throwStatement', () => {
+    this.CONSUME(T.Throw);
+    this.SUBRULE(this.expression);  // Error message is required
+  });
+
   private ifStatement = this.RULE('ifStatement', () => {
     this.CONSUME(T.If);
     this.SUBRULE(this.expression);
@@ -782,6 +792,10 @@ class VibeParser extends CstParser {
       this.CONSUME(T.Comma);
       this.SUBRULE2(this.expression);
     });
+    // Allow trailing comma
+    this.OPTION(() => {
+      this.CONSUME2(T.Comma);
+    });
   });
 }
 

package/src/parser/parse.ts

@@ -4,7 +4,7 @@ import { vibeAstVisitor } from './visitor';
 import { setCurrentFile } from './visitor/helpers';
 import { ParserError } from '../errors';
 import type { Program } from '../ast';
-import type { IRecognitionException } from 'chevrotain';
+import type { IRecognitionException, IToken } from 'chevrotain';
 
 export interface ParseOptions {
   /** File path to include in source locations (for error reporting) */
@@ -17,8 +17,21 @@ export interface ParseOptions {
 function improveErrorMessage(error: IRecognitionException): string {
   const ruleStack = error.context?.ruleStack ?? [];
   const previousToken = error.previousToken;
+  const currentToken = error.token;
   const message = error.message;
 
+  // Reserved word used where identifier expected
+  // Detected: message mentions "Identifier" and current token is a keyword/type token (not Identifier)
+  if (message.includes('Identifier') && currentToken?.image && currentToken?.tokenType?.name) {
+    const tokenTypeName = currentToken.tokenType.name;
+    // If parser expected Identifier but got a keyword/type token, it's a reserved word
+    if (tokenTypeName !== 'Identifier') {
+      const isType = tokenTypeName.endsWith('Type');
+      const kind = isType ? 'reserved type name' : 'reserved keyword';
+      return `Invalid identifier '${currentToken.image}' - '${currentToken.image}' is a ${kind}`;
+    }
+  }
+
   // Missing type annotation for function/tool parameter
   // Detected: in "parameter" or "toolParameter" rule, expected Colon, previous token is Identifier
   if (
@@ -29,9 +42,126 @@ function improveErrorMessage(error: IRecognitionException): string {
     return `Missing type annotation for parameter '${previousToken.image}'`;
   }
 
+  // Missing comma between properties in object/model declaration
+  // Detected: in objectLiteral/objectLiteralExpr, expected RBrace, found Identifier
+  if (
+    (ruleStack.includes('objectLiteral') || ruleStack.includes('objectLiteralExpr')) &&
+    message.includes('RBrace') &&
+    currentToken?.tokenType?.name === 'Identifier'
+  ) {
+    return `Missing comma between properties. Add ',' after the previous property`;
+  }
+
+  // Missing comma between elements in array
+  // Detected: in arrayLiteral, expected RBracket, found something else
+  if (
+    ruleStack.includes('arrayLiteral') &&
+    message.includes('RBracket') &&
+    currentToken?.tokenType?.name !== 'RBracket'
+  ) {
+    return `Missing comma between array elements. Add ',' after the previous element`;
+  }
+
   return message;
 }
 
+interface DelimiterInfo {
+  type: 'brace' | 'paren' | 'bracket';
+  token: IToken;
+  line: number;
+  column: number;
+}
+
+/**
+ * Check for unclosed or mismatched delimiters before parsing.
+ * Returns a ParserError if there's a delimiter issue, null otherwise.
+ */
+function checkDelimiters(tokens: IToken[], source: string, file?: string): ParserError | null {
+  const stack: DelimiterInfo[] = [];
+
+  const delimiterPairs: Record<string, { open: 'brace' | 'paren' | 'bracket'; close: 'brace' | 'paren' | 'bracket' }> = {
+    LBrace: { open: 'brace', close: 'brace' },
+    RBrace: { open: 'brace', close: 'brace' },
+    LParen: { open: 'paren', close: 'paren' },
+    RParen: { open: 'paren', close: 'paren' },
+    LBracket: { open: 'bracket', close: 'bracket' },
+    RBracket: { open: 'bracket', close: 'bracket' },
+  };
+
+  const delimiterNames: Record<string, string> = {
+    brace: 'brace',
+    paren: 'parenthesis',
+    bracket: 'bracket',
+  };
+
+  const openingChars: Record<string, string> = {
+    brace: '{',
+    paren: '(',
+    bracket: '[',
+  };
+
+  const closingChars: Record<string, string> = {
+    brace: '}',
+    paren: ')',
+    bracket: ']',
+  };
+
+  for (const token of tokens) {
+    const tokenName = token.tokenType.name;
+
+    // Opening delimiters
+    if (tokenName === 'LBrace' || tokenName === 'LParen' || tokenName === 'LBracket') {
+      const type = delimiterPairs[tokenName].open;
+      stack.push({
+        type,
+        token,
+        line: token.startLine ?? 1,
+        column: token.startColumn ?? 1,
+      });
+    }
+    // Closing delimiters
+    else if (tokenName === 'RBrace' || tokenName === 'RParen' || tokenName === 'RBracket') {
+      const expectedType = delimiterPairs[tokenName].close;
+
+      if (stack.length === 0) {
+        // Unmatched closing delimiter
+        return new ParserError(
+          `Unmatched closing ${delimiterNames[expectedType]} '${closingChars[expectedType]}'`,
+          token.image,
+          { line: token.startLine ?? 1, column: token.startColumn ?? 1, file },
+          source
+        );
+      }
+
+      const top = stack.pop()!;
+      if (top.type !== expectedType) {
+        // Mismatched delimiter - report at the closing delimiter but mention the opening
+        return new ParserError(
+          `Mismatched delimiters: expected closing ${delimiterNames[top.type]} '${closingChars[top.type]}' to match '${openingChars[top.type]}' at line ${top.line}, but found '${closingChars[expectedType]}'`,
+          token.image,
+          { line: token.startLine ?? 1, column: token.startColumn ?? 1, file },
+          source
+        );
+      }
+    }
+  }
+
+  // Check for unclosed delimiters
+  if (stack.length > 0) {
+    // Report the first unclosed delimiter (deepest nesting level that's unclosed)
+    // We want to report the innermost unclosed one, which is the last on the stack
+    const unclosed = stack[stack.length - 1];
+    return new ParserError(
+      `Unclosed ${delimiterNames[unclosed.type]} '${openingChars[unclosed.type]}' - missing '${closingChars[unclosed.type]}'`,
+      openingChars[unclosed.type],
+      { line: unclosed.line, column: unclosed.column, file },
+      source
+    );
+  }
+
+  return null;
+}
+
 /**
  * Parse a Vibe source code string into an AST
  */
@@ -42,6 +172,13 @@ export function parse(source: string, options?: ParseOptions): Program {
   // Tokenize
   const tokens = tokenize(source);
 
+  // Check for unclosed/mismatched delimiters first
+  // This provides better error messages than the parser for delimiter issues
+  const delimiterError = checkDelimiters(tokens, source, options?.file);
+  if (delimiterError) {
+    throw delimiterError;
+  }
+
   // Parse to CST
   vibeParser.input = tokens;
   const cst = vibeParser.program();

package/src/parser/test/errors/missing-tokens.test.ts

@@ -157,4 +157,29 @@ foo(
 greet("hello"
 `)).toThrow();
   });
+
+  // ============================================================================
+  // missing comma errors
+  // ============================================================================
+
+  test('object literal missing comma between properties', () => {
+    expect(() => parse(`let x = { a: 1 b: 2 }`)).toThrow(
+      "Missing comma between properties"
+    );
+  });
+
+  test('model declaration missing comma between properties', () => {
+    expect(() => parse(`
+model m = {
+  name: "test"
+  apiKey: "key"
+}
+`)).toThrow("Missing comma between properties");
+  });
+
+  test('array literal missing comma between elements', () => {
+    expect(() => parse(`let arr = [1 2 3]`)).toThrow(
+      "Missing comma between array elements"
+    );
+  });
 });

package/src/parser/test/errors/model-declaration.test.ts

@@ -133,26 +133,32 @@ model myModel = {
   name: "test"
   apiKey: "key"
 }
-`)).toThrow();
+`)).toThrow(/[Mm]issing comma/);
   });
 
-  test('properties with double comma', () => {
+  test('export model missing comma separator', () => {
     expect(() => parse(`
-model myModel = {
-  name: "test",,
-  apiKey: "key"
+export model gemini3Flash = {
+  name: 'gemini-flash-3',
+  provider: 'google',
+  apiKey: env('GOOGLE_API_KEY')
+  url: 'https://api.google.com/v1',
 }
-`)).toThrow();
+`)).toThrow(/[Mm]issing comma/);
   });
 
-  test('trailing comma without next property', () => {
+  test('properties with double comma', () => {
     expect(() => parse(`
 model myModel = {
-  name: "test",
+  name: "test",,
+  apiKey: "key"
 }
 `)).toThrow();
   });
 
+  // Note: trailing comma IS now allowed (test removed)
+  // model myModel = { name: "test", } is valid
+
   // ============================================================================
   // Model keyword misuse
   // ============================================================================

package/src/parser/test/errors/unclosed-delimiters.test.ts

@@ -1,80 +1,175 @@
 import { describe, expect, test } from 'bun:test';
 import { parse } from '../../parse';
+import { ParserError } from '../../../errors';
 
 describe('Syntax Errors - Unclosed Delimiters', () => {
   // ============================================================================
-  // Unclosed braces
+  // Unclosed braces - with location verification
   // ============================================================================
 
-  test('unclosed block statement', () => {
-    expect(() => parse(`
+  test('unclosed block statement reports location of opening brace', () => {
+    try {
+      parse(`
 {
   let x = "hello"
-`)).toThrow();
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unclosed brace '{'");
+      expect(err.location?.line).toBe(2); // Line where { is
+      expect(err.location?.column).toBe(1);
+    }
   });
 
-  test('unclosed function body', () => {
-    expect(() => parse(`
+  test('unclosed function body reports location of opening brace', () => {
+    try {
+      parse(`
 function foo() {
   return "hello"
-`)).toThrow();
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unclosed brace '{'");
+      expect(err.location?.line).toBe(2); // Line where function { is
+      expect(err.location?.column).toBe(16); // Column where { is
+    }
   });
 
-  test('unclosed if block', () => {
-    expect(() => parse(`
+  test('unclosed if block reports location of opening brace', () => {
+    try {
+      parse(`
 if true {
   let x = "yes"
-`)).toThrow();
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unclosed brace '{'");
+      expect(err.location?.line).toBe(2);
+    }
   });
 
-  test('unclosed else block', () => {
-    expect(() => parse(`
+  test('unclosed else block reports location of opening brace', () => {
+    try {
+      parse(`
 if true {
   let x = "yes"
 } else {
   let y = "no"
-`)).toThrow();
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unclosed brace '{'");
+      expect(err.location?.line).toBe(4); // Line where else { is
+    }
   });
 
-  test('nested unclosed braces', () => {
-    expect(() => parse(`
+  test('nested unclosed braces reports innermost unclosed', () => {
+    try {
+      parse(`
 function outer() {
   if true {
     let x = "nested"
 }
-`)).toThrow();
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      // The innermost unclosed brace is the 'if' block's brace
+      // But actually the outer function brace is unclosed since only one } appears
+      expect(err.message).toContain("Unclosed brace '{'");
+      expect(err.location?.line).toBe(2); // The function's { is unclosed
+    }
   });
 
   // ============================================================================
-  // Unclosed parentheses
+  // Unclosed parentheses - with location verification
   // ============================================================================
 
-  test('unclosed function call', () => {
-    expect(() => parse(`
+  test('unclosed function call reports location of opening paren', () => {
+    try {
+      parse(`
 foo("hello"
-`)).toThrow();
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unclosed parenthesis '('");
+      expect(err.location?.line).toBe(2); // Line where ( is
+    }
   });
 
-  test('unclosed function params', () => {
-    expect(() => parse(`
+  test('unclosed function params reports location of opening paren', () => {
+    try {
+      parse(`
 function greet(name, age
-`)).toThrow();
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unclosed parenthesis '('");
+      expect(err.location?.line).toBe(2);
+    }
   });
 
-  test('unclosed grouped expression', () => {
-    expect(() => parse(`
+  test('unclosed grouped expression reports location', () => {
+    try {
+      parse(`
 let x = ("hello"
-`)).toThrow();
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unclosed parenthesis '('");
+      expect(err.location?.line).toBe(2);
+    }
   });
 
-  test('nested unclosed parens in call', () => {
-    expect(() => parse(`
+  test('nested unclosed parens reports innermost', () => {
+    try {
+      parse(`
 outer(inner("deep"
-`)).toThrow();
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      // inner( is the innermost unclosed
+      expect(err.message).toContain("Unclosed parenthesis '('");
+    }
+  });
+
+  // ============================================================================
+  // Unclosed brackets - with location verification
+  // ============================================================================
+
+  test('unclosed array literal reports location', () => {
+    try {
+      parse(`
+let arr = [1, 2, 3
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unclosed bracket '['");
+      expect(err.location?.line).toBe(2);
+    }
   });
 
   // ============================================================================
-  // Unclosed strings
+  // Unclosed strings (handled by lexer, not delimiter checker)
   // ============================================================================
 
   test('unclosed double quote string', () => {
@@ -102,15 +197,86 @@ let x = vibe "what is 2+2?
   });
 
   // ============================================================================
-  // Mixed unclosed delimiters
+  // Mismatched delimiters
   // ============================================================================
 
-  test('unclosed brace and paren', () => {
-    expect(() => parse(`
+  test('mismatched closing brace vs paren', () => {
+    try {
+      parse(`
 function test() {
   foo(
 }
-`)).toThrow();
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Mismatched delimiters");
+      expect(err.message).toContain("expected closing parenthesis");
+    }
+  });
+
+  test('unmatched closing brace', () => {
+    try {
+      parse(`
+let x = 1
+}
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unmatched closing brace");
+      expect(err.location?.line).toBe(3);
+    }
+  });
+
+  test('unmatched closing paren', () => {
+    try {
+      parse(`
+let x = 1)
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unmatched closing parenthesis");
+    }
+  });
+
+  test('unmatched closing bracket', () => {
+    try {
+      parse(`
+let x = 1]
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unmatched closing bracket");
+    }
+  });
+
+  // ============================================================================
+  // While loop specific (from user's example)
+  // ============================================================================
+
+  test('unclosed while loop reports location of opening brace', () => {
+    try {
+      parse(`
+let keepGoing = true
+let count = 0
+
+while keepGoing {
+   count = count + 1
+`);
+      expect.unreachable('Should have thrown');
+    } catch (e) {
+      expect(e).toBeInstanceOf(ParserError);
+      const err = e as ParserError;
+      expect(err.message).toContain("Unclosed brace '{'");
+      expect(err.location?.line).toBe(5); // Line where while { is
+    }
   });
 
   test('unclosed string inside unclosed block', () => {

package/src/parser/test/errors/unexpected-tokens.test.ts

@@ -31,7 +31,21 @@ function() {
 function let() {
   return "hello"
 }
-`)).toThrow();
+`)).toThrow(/reserved keyword/);
+  });
+
+  test('function with type name as name', () => {
+    expect(() => parse(`
+function text(x: text, y: number): text {
+  return x + y
+}
+`)).toThrow(/reserved type name/);
+  });
+
+  test('variable with keyword as name', () => {
+    expect(() => parse(`
+let return = 5
+`)).toThrow(/reserved keyword/);
   });
 
   // ============================================================================

package/src/parser/test/literals.test.ts

@@ -401,4 +401,33 @@ describe('Parser - For-In Statement', () => {
     const inner = outer.body.body[0];
     expect(inner.type).toBe('ForInStatement');
   });
+
+  // Trailing commas
+  test('object literal with trailing comma', () => {
+    const ast = parse('let x = { a: 1, b: 2, }');
+    const obj = (ast.body[0] as any).initializer;
+    expect(obj.type).toBe('ObjectLiteral');
+    expect(obj.properties).toHaveLength(2);
+  });
+
+  test('array literal with trailing comma', () => {
+    const ast = parse('let x = [1, 2, 3,]');
+    const arr = (ast.body[0] as any).initializer;
+    expect(arr.type).toBe('ArrayLiteral');
+    expect(arr.elements).toHaveLength(3);
+  });
+
+  test('single element object with trailing comma', () => {
+    const ast = parse('let x = { a: 1, }');
+    const obj = (ast.body[0] as any).initializer;
+    expect(obj.type).toBe('ObjectLiteral');
+    expect(obj.properties).toHaveLength(1);
+  });
+
+  test('single element array with trailing comma', () => {
+    const ast = parse('let x = [1,]');
+    const arr = (ast.body[0] as any).initializer;
+    expect(arr.type).toBe('ArrayLiteral');
+    expect(arr.elements).toHaveLength(1);
+  });
 });