@vibe-lang/runtime 0.2.5

package/src/semantic/test/async-validation.test.ts

@@ -0,0 +1,301 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { analyze } from '../index';
+
+describe('Semantic Validation - Async Declarations', () => {
+  // ============================================================================
+  // Valid async let declarations
+  // ============================================================================
+
+  test('valid async let with do expression', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async let x: text = do "prompt" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async let with vibe expression', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async let x: text = vibe "prompt" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async let with ts block', () => {
+    const ast = parse(`
+async let x = ts() { return fetchData(); }
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async let with function call', () => {
+    const ast = parse(`
+function getData(): text { return "data" }
+async let x = getData()
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Valid async const declarations
+  // ============================================================================
+
+  test('valid async const with do expression', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async const x: text = do "prompt" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async const with vibe expression', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async const x: text = vibe "prompt" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async const with ts block', () => {
+    const ast = parse(`
+async const x = ts() { return fetchData(); }
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async const with function call', () => {
+    const ast = parse(`
+function getData(): text { return "data" }
+async const x = getData()
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Valid async destructuring declarations
+  // ============================================================================
+
+  test('valid async let destructuring with do expression', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async let {name: text, age: number} = do "get info" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async const destructuring with do expression', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async const {name: text, age: number} = do "get info" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Valid async standalone statements (fire-and-forget)
+  // ============================================================================
+
+  test('valid async do statement', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async do "log something" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async vibe statement', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async vibe "process data" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async ts block statement', () => {
+    const ast = parse(`
+async ts() { console.log("fire and forget"); }
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async function call statement', () => {
+    const ast = parse(`
+function logEvent(msg: text): text { return msg }
+async logEvent("event")
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Invalid async declarations - caught at parse time
+  // Note: Invalid async expressions (literals, identifiers, etc.) are caught
+  // by the parser grammar, not semantic analysis. These tests verify parse errors.
+  // ============================================================================
+
+  test('async let with string literal fails at parse time', () => {
+    expect(() => parse(`async let x = "hello"`)).toThrow();
+  });
+
+  test('async let with number literal fails at parse time', () => {
+    expect(() => parse(`async let x = 42`)).toThrow();
+  });
+
+  test('async let with identifier is invalid (semantic error)', () => {
+    const ast = parse(`
+let data = "test"
+async let x = data
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain('async declarations require a single do, vibe, ts block, or function call');
+  });
+
+  test('untyped let with do expression requires type annotation', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+let x = do "prompt" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain('Type cannot be inferred from AI call');
+  });
+
+  test('untyped let with vibe expression requires type annotation', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+let x = vibe "prompt" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toContain('Type cannot be inferred from AI call');
+  });
+
+  test('async const with literal fails at parse time', () => {
+    expect(() => parse(`async const x = "hello"`)).toThrow();
+  });
+
+  // ============================================================================
+  // Async declarations with type annotations (valid)
+  // ============================================================================
+
+  test('valid async let with type annotation', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async let x: text = do "prompt" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async const with type annotation', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async const x: number = do "give number" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Async declarations with private modifier (valid)
+  // ============================================================================
+
+  test('valid async let with private modifier', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async let private secret: text = do "get secret" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('valid async const with private modifier', () => {
+    const ast = parse(`
+function getKey(): text { return "key" }
+async const private API_KEY = getKey()
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Multiple async declarations (valid)
+  // ============================================================================
+
+  test('multiple async let declarations are valid', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async let a: text = do "1" m
+async let b: text = do "2" m
+async let c: text = do "3" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('mixed async and sync declarations are valid', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+let sync1 = "hello"
+async let async1: text = do "prompt" m
+const sync2 = 42
+async const async2 = ts() { return fetchData(); }
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Async with method calls (valid)
+  // ============================================================================
+
+  test('valid async method call statement', () => {
+    const ast = parse(`
+let api = "api"
+async api.sendNotification("done")
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Using async declared variables (valid)
+  // ============================================================================
+
+  test('can use async declared variables in expressions', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async let x: text = do "1" m
+async let y: text = do "2" m
+let result = x + y
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('async declared variable can be used as dependency', () => {
+    const ast = parse(`
+model m = { name: "test", apiKey: "key", url: "http://test" }
+async let x: text = do "get data" m
+async let y: text = do "use {x}" m
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+});

package/src/semantic/test/compress-validation.test.ts

@@ -0,0 +1,179 @@
+import { describe, test, expect } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { SemanticAnalyzer } from '../analyzer';
+
+function getErrors(source: string): string[] {
+  const ast = parse(source);
+  const analyzer = new SemanticAnalyzer();
+  return analyzer.analyze(ast, source).map((e) => e.message);
+}
+
+describe('Compress Context Mode Validation', () => {
+  describe('valid compress usage', () => {
+    test('compress with no arguments is valid', () => {
+      const errors = getErrors(`
+        for i in [1, 2, 3] {
+          let x = i
+        } compress
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('compress with string literal is valid', () => {
+      const errors = getErrors(`
+        for i in [1, 2, 3] {
+          let x = i
+        } compress("summarize")
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('compress with model identifier is valid', () => {
+      const errors = getErrors(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        for i in [1, 2, 3] {
+          let x = i
+        } compress(m)
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('compress with prompt variable is valid', () => {
+      const errors = getErrors(`
+        const SUMMARY: prompt = "summarize the loop"
+        for i in [1, 2, 3] {
+          let x = i
+        } compress(SUMMARY)
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('compress with text variable is valid (treated as prompt)', () => {
+      const errors = getErrors(`
+        const summary: text = "summarize the loop"
+        for i in [1, 2, 3] {
+          let x = i
+        } compress(summary)
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('compress with string literal and model is valid', () => {
+      const errors = getErrors(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        for i in [1, 2, 3] {
+          let x = i
+        } compress("summarize", m)
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('compress with prompt variable and model is valid', () => {
+      const errors = getErrors(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        const SUMMARY: prompt = "summarize the loop"
+        for i in [1, 2, 3] {
+          let x = i
+        } compress(SUMMARY, m)
+      `);
+      expect(errors).toEqual([]);
+    });
+  });
+
+  describe('invalid compress usage', () => {
+    test('compress with undeclared identifier reports error', () => {
+      const errors = getErrors(`
+        for i in [1, 2, 3] {
+          let x = i
+        } compress(undeclared)
+      `);
+      expect(errors).toContain("compress argument 'undeclared' is not declared");
+    });
+
+    test('compress with undeclared model identifier reports error', () => {
+      const errors = getErrors(`
+        const SUMMARY: prompt = "summarize"
+        for i in [1, 2, 3] {
+          let x = i
+        } compress(SUMMARY, undeclaredModel)
+      `);
+      expect(errors).toContain("compress model 'undeclaredModel' is not declared");
+    });
+
+    test('compress with json variable reports error', () => {
+      const errors = getErrors(`
+        const config: json = { key: "value" }
+        for i in [1, 2, 3] {
+          let x = i
+        } compress(config)
+      `);
+      expect(errors).toContain("compress argument 'config' must be prompt or model type, got json");
+    });
+
+    test('compress with number variable reports error', () => {
+      const errors = getErrors(`
+        const num: number = 42
+        for i in [1, 2, 3] {
+          let x = i
+        } compress(num)
+      `);
+      expect(errors).toContain("compress argument 'num' must be prompt or model type, got number");
+    });
+
+    test('compress with function as argument reports error', () => {
+      const errors = getErrors(`
+        function myFunc(x: text): text { return x }
+        for i in [1, 2, 3] {
+          let x = i
+        } compress(myFunc)
+      `);
+      expect(errors).toContain("compress argument 'myFunc' must be prompt or model type, got function");
+    });
+
+    test('compress second arg must be model type', () => {
+      const errors = getErrors(`
+        const SUMMARY: prompt = "summarize"
+        const notModel: text = "not a model"
+        for i in [1, 2, 3] {
+          let x = i
+        } compress(SUMMARY, notModel)
+      `);
+      expect(errors).toContain("compress second argument 'notModel' must be model type, got text");
+    });
+
+    test('compress first arg must be prompt type when two args provided', () => {
+      const errors = getErrors(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        const config: json = { key: "value" }
+        for i in [1, 2, 3] {
+          let x = i
+        } compress(config, m)
+      `);
+      expect(errors).toContain("compress first argument 'config' must be prompt type when two arguments provided, got json");
+    });
+  });
+
+  describe('while loop compress validation', () => {
+    test('while loop compress with model is valid', () => {
+      const errors = getErrors(`
+        model m = { name: "test", apiKey: "key", url: "http://test" }
+        let i = 0
+        while (i < 3) {
+          i = i + 1
+        } compress(m)
+      `);
+      expect(errors).toEqual([]);
+    });
+
+    test('while loop compress with invalid type reports error', () => {
+      const errors = getErrors(`
+        const num: number = 42
+        let i = 0
+        while (i < 3) {
+          i = i + 1
+        } compress(num)
+      `);
+      expect(errors).toContain("compress argument 'num' must be prompt or model type, got number");
+    });
+  });
+});

package/src/semantic/test/const-reassignment.test.ts

@@ -0,0 +1,111 @@
+import { describe, expect, test } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { analyze } from '../index';
+
+describe('Semantic Errors - Const Reassignment', () => {
+  // ============================================================================
+  // Basic const reassignment
+  // ============================================================================
+
+  test('cannot reassign const variable', () => {
+    const ast = parse(`
+const x = "hello"
+x = "world"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Cannot reassign constant 'x'");
+  });
+
+  test('can reassign let variable', () => {
+    const ast = parse(`
+let x = "hello"
+x = "world"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Const reassignment in different scopes
+  // ============================================================================
+
+  test('cannot reassign const in nested block', () => {
+    const ast = parse(`
+const x = "hello"
+if true {
+  x = "world"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Cannot reassign constant 'x'");
+  });
+
+  test('cannot reassign const in function', () => {
+    const ast = parse(`
+const x = "hello"
+function test() {
+  x = "world"
+  return x
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(1);
+    expect(errors[0].message).toBe("Cannot reassign constant 'x'");
+  });
+
+  // ============================================================================
+  // Shadowing vs reassignment
+  // ============================================================================
+
+  test('shadowing const with let in nested scope is valid', () => {
+    const ast = parse(`
+const x = "outer"
+if true {
+  let x = "inner"
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  test('shadowing const with const in nested scope is valid', () => {
+    const ast = parse(`
+const x = "outer"
+function test() {
+  const x = "inner"
+  return x
+}
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(0);
+  });
+
+  // ============================================================================
+  // Multiple reassignments
+  // ============================================================================
+
+  test('multiple const reassignments report multiple errors', () => {
+    const ast = parse(`
+const x = "hello"
+x = "world"
+x = "again"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+    expect(errors[0].message).toBe("Cannot reassign constant 'x'");
+    expect(errors[1].message).toBe("Cannot reassign constant 'x'");
+  });
+
+  test('reassigning different consts reports separate errors', () => {
+    const ast = parse(`
+const x = "hello"
+const y = "world"
+x = "new x"
+y = "new y"
+`);
+    const errors = analyze(ast);
+    expect(errors.length).toBe(2);
+  });
+});