@vibe-lang/runtime 0.2.8 → 0.2.9

package/package.json

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

package/src/parser/index.ts

@@ -316,6 +316,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', () => {
@@ -782,6 +786,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

@@ -17,6 +17,7 @@ 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;
 
   // Missing type annotation for function/tool parameter
@@ -29,6 +30,26 @@ 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;
 }
 

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

@@ -145,13 +145,8 @@ model myModel = {
 `)).toThrow();
   });
 
-  test('trailing comma without next property', () => {
-    expect(() => parse(`
-model myModel = {
-  name: "test",
-}
-`)).toThrow();
-  });
+  // Note: trailing comma IS now allowed (test removed)
+  // model myModel = { name: "test", } is valid
 
   // ============================================================================
   // Model keyword misuse

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);
+  });
 });

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

@@ -110,6 +110,20 @@ model myModel = {
     expect(model.config.apiKey.value).toBe('sk-test');
     expect(model.config.url.value).toBe('https://api.openai.com');
   });
+
+  test('model with trailing comma', () => {
+    const ast = parse(`
+model myModel = {
+  name: "gpt-4",
+  apiKey: "sk-test",
+  url: "https://api.openai.com",
+}
+`);
+    expect(ast.body).toHaveLength(1);
+    const model = ast.body[0] as any;
+    expect(model.type).toBe('ModelDeclaration');
+    expect(model.config.providedFields).toEqual(['name', 'apiKey', 'url']);
+  });
 });
 
 describe('Syntax Errors - Model Declaration', () => {

package/src/runtime/async/dependencies.ts

@@ -83,8 +83,15 @@ export function getReferencedVariables(expr: AST.Expression): string[] {
         }
         break;
 
-      // Literals don't reference variables
       case 'StringLiteral':
+        // Extract variables from {varName} and !{varName} interpolation in strings
+        const stringMatches = node.value.matchAll(/!?\{([a-zA-Z_][a-zA-Z0-9_]*)\}/g);
+        for (const match of stringMatches) {
+          variables.push(match[1]);
+        }
+        break;
+
+      // These literals don't reference variables
       case 'NumberLiteral':
       case 'BooleanLiteral':
       case 'NullLiteral':

package/src/runtime/async/test/dependencies.test.ts

@@ -22,11 +22,37 @@ describe('Async Dependency Detection', () => {
       expect(getReferencedVariables(expr)).toEqual(['myVar']);
     });
 
-    test('extracts no variables from string literal', () => {
+    test('extracts no variables from plain string literal', () => {
       const expr = parseExpr('"hello"');
       expect(getReferencedVariables(expr)).toEqual([]);
     });
 
+    test('extracts variables from string literal with {var} interpolation', () => {
+      const expr = parseExpr('"Hello {name}!"');
+      const vars = getReferencedVariables(expr);
+      expect(vars).toContain('name');
+    });
+
+    test('extracts variables from string literal with !{var} expansion', () => {
+      const expr = parseExpr('"Process this: !{data}"');
+      const vars = getReferencedVariables(expr);
+      expect(vars).toContain('data');
+    });
+
+    test('extracts multiple variables from string literal interpolation', () => {
+      const expr = parseExpr('"Hello {greeting} {name}, your data is !{info}"');
+      const vars = getReferencedVariables(expr);
+      expect(vars).toContain('greeting');
+      expect(vars).toContain('name');
+      expect(vars).toContain('info');
+    });
+
+    test('extracts variables from single-quoted string with interpolation', () => {
+      const expr = parseExpr("'User: {user}'");
+      const vars = getReferencedVariables(expr);
+      expect(vars).toContain('user');
+    });
+
     test('extracts no variables from number literal', () => {
       const expr = parseExpr('42');
       expect(getReferencedVariables(expr)).toEqual([]);

package/src/runtime/stdlib/tools/index.ts

@@ -567,12 +567,12 @@ export const runCode: VibeToolValue = {
   schema: {
     name: 'runCode',
     description:
-      'Execute TypeScript/JavaScript code in a sandboxed subprocess. ' +
+      'Execute TypeScript code in a sandboxed subprocess. IMPORTANT: Only write TypeScript code, never Python or other languages. ' +
       'All scope variables are automatically available as local variables. ' +
       'Use `return value` to pass results back. Bun APIs are available. ' +
       'Each execution creates a unique folder in .vibe-cache/ for intermediate files.',
     parameters: [
-      { name: 'code', type: { type: 'string' }, description: 'TypeScript/JavaScript code to execute', required: true },
+      { name: 'code', type: { type: 'string' }, description: 'TypeScript code to execute (not Python or other languages)', required: true },
       { name: 'scope', type: { type: 'object', additionalProperties: true }, description: 'Variables to make available in the code', required: false },
       { name: 'timeout', type: { type: 'number' }, description: 'Timeout in milliseconds (default: 30000)', required: false },
     ],