@vibe-lang/runtime 0.2.5

package/src/parser/test/private.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect } from 'bun:test';
+import { parse } from '../parse';
+import type * as AST from '../../ast';
+
+describe('private keyword parsing', () => {
+  describe('let private', () => {
+    it('parses let private with type annotation', () => {
+      const code = 'let private apiKey: text = "secret"';
+      const ast = parse(code);
+
+      expect(ast.body.length).toBe(1);
+      const decl = ast.body[0] as AST.LetDeclaration;
+      expect(decl.type).toBe('LetDeclaration');
+      expect(decl.name).toBe('apiKey');
+      expect(decl.typeAnnotation).toBe('text');
+      expect(decl.isPrivate).toBe(true);
+    });
+
+    it('parses let private without type annotation', () => {
+      const code = 'let private counter = 0';
+      const ast = parse(code);
+
+      const decl = ast.body[0] as AST.LetDeclaration;
+      expect(decl.type).toBe('LetDeclaration');
+      expect(decl.name).toBe('counter');
+      expect(decl.typeAnnotation).toBeNull();
+      expect(decl.isPrivate).toBe(true);
+    });
+
+    it('parses regular let without private', () => {
+      const code = 'let publicVar: text = "visible"';
+      const ast = parse(code);
+
+      const decl = ast.body[0] as AST.LetDeclaration;
+      expect(decl.type).toBe('LetDeclaration');
+      expect(decl.name).toBe('publicVar');
+      expect(decl.isPrivate).toBeUndefined();
+    });
+  });
+
+  describe('const private', () => {
+    it('parses const private with type annotation', () => {
+      const code = 'const private SECRET: text = "password"';
+      const ast = parse(code);
+
+      expect(ast.body.length).toBe(1);
+      const decl = ast.body[0] as AST.ConstDeclaration;
+      expect(decl.type).toBe('ConstDeclaration');
+      expect(decl.name).toBe('SECRET');
+      expect(decl.typeAnnotation).toBe('text');
+      expect(decl.isPrivate).toBe(true);
+    });
+
+    it('parses const private without type annotation', () => {
+      const code = 'const private MAX_RETRIES = 3';
+      const ast = parse(code);
+
+      const decl = ast.body[0] as AST.ConstDeclaration;
+      expect(decl.type).toBe('ConstDeclaration');
+      expect(decl.name).toBe('MAX_RETRIES');
+      expect(decl.isPrivate).toBe(true);
+    });
+
+    it('parses regular const without private', () => {
+      const code = 'const publicConst = "visible"';
+      const ast = parse(code);
+
+      const decl = ast.body[0] as AST.ConstDeclaration;
+      expect(decl.type).toBe('ConstDeclaration');
+      expect(decl.name).toBe('publicConst');
+      expect(decl.isPrivate).toBeUndefined();
+    });
+  });
+
+  describe('destructuring with private fields', () => {
+    it('parses destructuring with private field', () => {
+      const code = 'let {private x: text, y: number} = someExpr';
+      const ast = parse(code);
+
+      const decl = ast.body[0] as AST.DestructuringDeclaration;
+      expect(decl.type).toBe('DestructuringDeclaration');
+      expect(decl.fields.length).toBe(2);
+
+      expect(decl.fields[0].name).toBe('x');
+      expect(decl.fields[0].type).toBe('text');
+      expect(decl.fields[0].isPrivate).toBe(true);
+
+      expect(decl.fields[1].name).toBe('y');
+      expect(decl.fields[1].type).toBe('number');
+      expect(decl.fields[1].isPrivate).toBeUndefined();
+    });
+
+    it('parses destructuring with all private fields', () => {
+      const code = 'const {private a: text, private b: number} = someExpr';
+      const ast = parse(code);
+
+      const decl = ast.body[0] as AST.DestructuringDeclaration;
+      expect(decl.isConst).toBe(true);
+      expect(decl.fields.length).toBe(2);
+
+      expect(decl.fields[0].name).toBe('a');
+      expect(decl.fields[0].isPrivate).toBe(true);
+
+      expect(decl.fields[1].name).toBe('b');
+      expect(decl.fields[1].isPrivate).toBe(true);
+    });
+
+    it('parses destructuring with no private fields', () => {
+      const code = 'let {x: text, y: number} = someExpr';
+      const ast = parse(code);
+
+      const decl = ast.body[0] as AST.DestructuringDeclaration;
+      expect(decl.fields[0].isPrivate).toBeUndefined();
+      expect(decl.fields[1].isPrivate).toBeUndefined();
+    });
+  });
+
+  describe('mixed declarations', () => {
+    it('parses multiple declarations with mixed visibility', () => {
+      const code = `
+        let private secret: text = "hidden"
+        let visible: text = "shown"
+        const private PASSWORD: text = "***"
+        const PUBLIC_KEY: text = "key"
+      `;
+      const ast = parse(code);
+
+      expect(ast.body.length).toBe(4);
+
+      expect((ast.body[0] as AST.LetDeclaration).isPrivate).toBe(true);
+      expect((ast.body[1] as AST.LetDeclaration).isPrivate).toBeUndefined();
+      expect((ast.body[2] as AST.ConstDeclaration).isPrivate).toBe(true);
+      expect((ast.body[3] as AST.ConstDeclaration).isPrivate).toBeUndefined();
+    });
+  });
+});

package/src/parser/test/template-literal.test.ts

@@ -0,0 +1,127 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../parse';
+
+describe('Parser - Template Literals', () => {
+  test('basic template literal', () => {
+    const ast = parse('let x = `hello`');
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'LetDeclaration',
+      name: 'x',
+      initializer: {
+        type: 'TemplateLiteral',
+        value: 'hello',
+      },
+    });
+  });
+
+  test('template literal with interpolation syntax preserved', () => {
+    const ast = parse('let x = `hello ${name}`');
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'LetDeclaration',
+      name: 'x',
+      initializer: {
+        type: 'TemplateLiteral',
+        value: 'hello ${name}',
+      },
+    });
+  });
+
+  test('template literal multiline', () => {
+    const ast = parse(`let x = \`line1
+line2\``);
+    expect(ast.body).toHaveLength(1);
+    const init = (ast.body[0] as any).initializer;
+    expect(init.type).toBe('TemplateLiteral');
+    expect(init.value).toBe('line1\nline2');
+  });
+
+  test('template literal with escape sequences', () => {
+    // Note: Current escape handling just removes the backslash
+    // Full JS-style escape handling (\\n → newline) could be added later
+    const ast = parse('let x = `hello\\nworld`');
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'LetDeclaration',
+      name: 'x',
+      initializer: {
+        type: 'TemplateLiteral',
+        value: 'hellonworld',
+      },
+    });
+  });
+
+  test('template literal with escaped backtick', () => {
+    const ast = parse('let x = `hello\\`world`');
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'LetDeclaration',
+      name: 'x',
+      initializer: {
+        type: 'TemplateLiteral',
+        value: 'hello`world',
+      },
+    });
+  });
+
+  test('template literal in const declaration', () => {
+    const ast = parse('const msg = `hello world`');
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'ConstDeclaration',
+      name: 'msg',
+      initializer: {
+        type: 'TemplateLiteral',
+        value: 'hello world',
+      },
+    });
+  });
+
+  test('template literal in function return', () => {
+    const ast = parse(`
+      function greet() {
+        return \`hello\`
+      }
+    `);
+    const func = ast.body[0] as any;
+    const returnStmt = func.body.body[0];
+    expect(returnStmt.type).toBe('ReturnStatement');
+    expect(returnStmt.value.type).toBe('TemplateLiteral');
+    expect(returnStmt.value.value).toBe('hello');
+  });
+
+  test('template literal as function argument', () => {
+    const ast = parse('myFunc(`hello ${name}`)');
+    const call = (ast.body[0] as any).expression;
+    expect(call.type).toBe('CallExpression');
+    expect(call.arguments[0].type).toBe('TemplateLiteral');
+    expect(call.arguments[0].value).toBe('hello ${name}');
+  });
+
+  test('template literal with multiple interpolations', () => {
+    const ast = parse('let x = `${greeting}, ${name}!`');
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'LetDeclaration',
+      name: 'x',
+      initializer: {
+        type: 'TemplateLiteral',
+        value: '${greeting}, ${name}!',
+      },
+    });
+  });
+
+  test('empty template literal', () => {
+    const ast = parse('let x = ``');
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'LetDeclaration',
+      name: 'x',
+      initializer: {
+        type: 'TemplateLiteral',
+        value: '',
+      },
+    });
+  });
+});

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

@@ -0,0 +1,302 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../parse';
+
+describe('Parser - Tool Declaration', () => {
+  // ============================================================================
+  // Basic tool declarations
+  // ============================================================================
+
+  test('simple tool with no parameters', () => {
+    const ast = parse(`
+tool getCurrentTime(): text
+  @description "Get the current time"
+{
+  ts() {
+    return new Date().toISOString()
+  }
+}
+`);
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'ToolDeclaration',
+      name: 'getCurrentTime',
+      params: [],
+      returnType: 'text',
+      description: 'Get the current time',
+    });
+  });
+
+  test('tool with single parameter', () => {
+    const ast = parse(`
+tool greet(name: text): text
+  @description "Greet someone"
+{
+  ts(name) {
+    return "Hello, " + name
+  }
+}
+`);
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'ToolDeclaration',
+      name: 'greet',
+      params: [
+        { name: 'name', typeAnnotation: 'text' },
+      ],
+      returnType: 'text',
+      description: 'Greet someone',
+    });
+  });
+
+  test('tool with multiple parameters', () => {
+    const ast = parse(`
+tool calculate(x: number, y: number, op: text): number
+  @description "Perform a calculation"
+{
+  ts(x, y, op) {
+    if (op === "add") return x + y
+    if (op === "mul") return x * y
+    return 0
+  }
+}
+`);
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'ToolDeclaration',
+      name: 'calculate',
+      params: [
+        { name: 'x', typeAnnotation: 'number' },
+        { name: 'y', typeAnnotation: 'number' },
+        { name: 'op', typeAnnotation: 'text' },
+      ],
+      returnType: 'number',
+    });
+  });
+
+  // ============================================================================
+  // Tool with @param descriptions
+  // ============================================================================
+
+  test('tool with @param descriptions', () => {
+    const ast = parse(`
+tool fetchUrl(url: text): json
+  @description "Fetch data from a URL"
+  @param url "The URL to fetch from"
+{
+  ts(url) {
+    const response = await fetch(url)
+    return await response.json()
+  }
+}
+`);
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'ToolDeclaration',
+      name: 'fetchUrl',
+      params: [
+        { name: 'url', typeAnnotation: 'text', description: 'The URL to fetch from' },
+      ],
+      description: 'Fetch data from a URL',
+    });
+  });
+
+  test('tool with multiple @param descriptions', () => {
+    const ast = parse(`
+tool sendEmail(to: text, subject: text, body: text): boolean
+  @description "Send an email"
+  @param to "The recipient email address"
+  @param subject "The email subject line"
+  @param body "The email body content"
+{
+  ts(to, subject, body) {
+    return true
+  }
+}
+`);
+    expect(ast.body).toHaveLength(1);
+    const toolDecl = ast.body[0];
+    expect(toolDecl.type).toBe('ToolDeclaration');
+    if (toolDecl.type === 'ToolDeclaration') {
+      expect(toolDecl.params).toHaveLength(3);
+      expect(toolDecl.params[0].description).toBe('The recipient email address');
+      expect(toolDecl.params[1].description).toBe('The email subject line');
+      expect(toolDecl.params[2].description).toBe('The email body content');
+    }
+  });
+
+  // ============================================================================
+  // Tool type annotations
+  // ============================================================================
+
+  test('tool with json return type', () => {
+    const ast = parse(`
+tool getData(): json
+  @description "Get some data"
+{
+  ts() {
+    return { foo: "bar" }
+  }
+}
+`);
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'ToolDeclaration',
+      name: 'getData',
+      returnType: 'json',
+    });
+  });
+
+  test('tool with boolean return type', () => {
+    const ast = parse(`
+tool isValid(value: text): boolean
+  @description "Check if value is valid"
+{
+  ts(value) {
+    return value.length > 0
+  }
+}
+`);
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'ToolDeclaration',
+      returnType: 'boolean',
+    });
+  });
+
+  test('tool with array type parameter', () => {
+    const ast = parse(`
+tool sum(numbers: number[]): number
+  @description "Sum all numbers"
+{
+  ts(numbers) {
+    return numbers.reduce((a, b) => a + b, 0)
+  }
+}
+`);
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'ToolDeclaration',
+      params: [
+        { name: 'numbers', typeAnnotation: 'number[]' },
+      ],
+      returnType: 'number',
+    });
+  });
+
+  // ============================================================================
+  // Tool with imported TypeScript types
+  // ============================================================================
+
+  test('tool with imported type as parameter', () => {
+    // Note: Currently uses regular import syntax. Type imports would be:
+    // import type { CustomerInfo } from "./types.ts"
+    const ast = parse(`
+import { CustomerInfo } from "./types.ts"
+
+tool processCustomer(info: CustomerInfo): json
+  @description "Process customer information"
+{
+  ts(info) {
+    return { processed: true }
+  }
+}
+`);
+    expect(ast.body).toHaveLength(2);
+    expect(ast.body[0].type).toBe('ImportDeclaration');
+    expect(ast.body[1]).toMatchObject({
+      type: 'ToolDeclaration',
+      name: 'processCustomer',
+      params: [
+        { name: 'info', typeAnnotation: 'CustomerInfo' },
+      ],
+    });
+  });
+
+  // ============================================================================
+  // Multiple tools
+  // ============================================================================
+
+  test('multiple tool declarations', () => {
+    const ast = parse(`
+tool add(a: number, b: number): number
+  @description "Add two numbers"
+{
+  ts(a, b) { return a + b }
+}
+
+tool multiply(a: number, b: number): number
+  @description "Multiply two numbers"
+{
+  ts(a, b) { return a * b }
+}
+`);
+    expect(ast.body).toHaveLength(2);
+    expect(ast.body[0]).toMatchObject({
+      type: 'ToolDeclaration',
+      name: 'add',
+    });
+    expect(ast.body[1]).toMatchObject({
+      type: 'ToolDeclaration',
+      name: 'multiply',
+    });
+  });
+
+  // ============================================================================
+  // Tool with no return type
+  // ============================================================================
+
+  test('tool without return type annotation', () => {
+    const ast = parse(`
+tool logMessage(message: text)
+  @description "Log a message"
+{
+  ts(message) {
+    console.log(message)
+  }
+}
+`);
+    expect(ast.body).toHaveLength(1);
+    expect(ast.body[0]).toMatchObject({
+      type: 'ToolDeclaration',
+      name: 'logMessage',
+      returnType: null,
+    });
+  });
+});
+
+describe('Syntax Errors - Tool Declaration', () => {
+  test('tool missing name', () => {
+    expect(() => parse(`
+tool (x: text): text
+  @description "test"
+{
+  ts(x) { return x }
+}
+`)).toThrow();
+  });
+
+  test('tool missing body', () => {
+    expect(() => parse(`
+tool test(): text
+  @description "test"
+`)).toThrow();
+  });
+
+  // Note: Type validation happens at semantic analysis, not parsing.
+  // The parser accepts any identifier as a type, including custom types
+  // from imports. So "invalidType" is valid syntax that would fail later.
+  test('tool with custom type parameter parses successfully', () => {
+    // This is valid syntax - type validation happens later
+    const ast = parse(`
+tool test(x: CustomType): text
+  @description "test"
+{
+  ts(x) { return x }
+}
+`);
+    expect(ast.body[0]).toMatchObject({
+      type: 'ToolDeclaration',
+      params: [{ name: 'x', typeAnnotation: 'CustomType' }],
+    });
+  });
+});