@vibe-lang/runtime 0.2.5

package/src/runtime/test/null-handling.test.ts

@@ -0,0 +1,342 @@
+import { describe, it, expect } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { SemanticAnalyzer } from '../../semantic/analyzer';
+import { createInitialState, resumeWithTsResult } from '../state';
+import { runUntilPause } from '../step';
+import { isVibeValue } from '../types';
+
+const analyzer = new SemanticAnalyzer();
+
+function getErrors(source: string): string[] {
+  const ast = parse(source);
+  return analyzer.analyze(ast, source).map((e) => e.message);
+}
+
+describe('Null Handling', () => {
+  describe('null literal parsing', () => {
+    it('parses null as a literal value', () => {
+      const ast = parse('let x: text = null');
+      expect(ast.body[0].type).toBe('LetDeclaration');
+      const decl = ast.body[0] as { initializer: { type: string } };
+      expect(decl.initializer.type).toBe('NullLiteral');
+    });
+
+    it('parses null in expressions', () => {
+      const ast = parse('let x: text = null\nlet y = x == null');
+      expect(ast.body.length).toBe(2);
+    });
+  });
+
+  describe('semantic validation for null assignments', () => {
+    it('rejects const with null initializer', () => {
+      const errors = getErrors('const x = null');
+      expect(errors.some(e => e.includes('Cannot initialize const with null'))).toBe(true);
+    });
+
+    it('rejects const with typed null initializer', () => {
+      const errors = getErrors('const x: text = null');
+      expect(errors.some(e => e.includes('Cannot initialize const with null'))).toBe(true);
+    });
+
+    it('rejects let without type annotation when initialized with null', () => {
+      const errors = getErrors('let x = null');
+      expect(errors.some(e => e.includes('Cannot infer type from null'))).toBe(true);
+    });
+
+    it('accepts let with type annotation initialized with null', () => {
+      const errors = getErrors('let x: text = null');
+      expect(errors.filter(e => e.includes('null'))).toEqual([]);
+    });
+
+    it('accepts let with json type initialized with null', () => {
+      const errors = getErrors('let x: json = null');
+      expect(errors.filter(e => e.includes('null'))).toEqual([]);
+    });
+  });
+
+  describe('null in runtime operations', () => {
+    it('evaluates null literal to null', () => {
+      const ast = parse('let x: text = null');
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      expect(state.callStack[0].locals['x'].value).toBe(null);
+    });
+
+    it('allows reassigning typed variable to null', () => {
+      const ast = parse(`
+        let x: text = "hello"
+        x = null
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      expect(state.callStack[0].locals['x'].value).toBe(null);
+    });
+
+    it('compares null with == correctly', () => {
+      const ast = parse(`
+        let x: text = null
+        let isNull = x == null
+        let isNotNull = x != null
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      expect(state.callStack[0].locals['isNull'].value).toBe(true);
+      expect(state.callStack[0].locals['isNotNull'].value).toBe(false);
+    });
+
+    it('string concatenation with null coerces null to empty string', () => {
+      const ast = parse(`
+        let x: text = null
+        let result1 = "hello " + x
+        let result2 = x + " world"
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      expect(state.callStack[0].locals['result1'].value).toBe('hello ');
+      expect(state.callStack[0].locals['result2'].value).toBe(' world');
+    });
+
+    it('arithmetic with null creates error VibeValue', () => {
+      const ast = parse(`
+        let x: number = null
+        let result = x + 5
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      const result = state.callStack[0].locals['result'];
+      expect(isVibeValue(result)).toBe(true);
+      expect(result.err).toBe(true);  // err is now boolean
+      expect(result.errDetails?.message).toContain('null');
+    });
+
+    it('subtraction with null creates error', () => {
+      const ast = parse(`
+        let x: number = null
+        let result = 10 - x
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      const result = state.callStack[0].locals['result'];
+      expect(result.err).toBe(true);  // err is now boolean
+    });
+
+    it('multiplication with null creates error', () => {
+      const ast = parse(`
+        let x: number = null
+        let result = x * 5
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      const result = state.callStack[0].locals['result'];
+      expect(result.err).toBe(true);  // err is now boolean
+    });
+
+    it('unary minus on null creates error', () => {
+      const ast = parse(`
+        let x: number = null
+        let result = -x
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      const result = state.callStack[0].locals['result'];
+      expect(result.err).toBe(true);  // err is now boolean
+      expect(result.errDetails?.message).toContain('null');
+    });
+
+    it('logical operators treat null as falsy', () => {
+      const ast = parse(`
+        let x: text = null
+        let andResult = x and true
+        let orResult = x or "default"
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      expect(state.callStack[0].locals['andResult'].value).toBe(false);
+      expect(state.callStack[0].locals['orResult'].value).toBe(true);
+    });
+  });
+
+  describe('error propagation through expressions (docs example)', () => {
+    it('error propagates through a + b when a has error', () => {
+      // Matches the docs example: let sum = a + b where a might fail
+      const ast = parse(`
+        let a: number = null
+        let b = 10
+        let sum = a + b
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      // sum should have the error from a
+      const sum = state.callStack[0].locals['sum'];
+      expect(isVibeValue(sum)).toBe(true);
+      expect(sum.err).toBe(true);
+      expect(sum.errDetails?.message).toContain('null');
+    });
+
+    it('error propagates through a + b when b has error', () => {
+      const ast = parse(`
+        let a = 10
+        let b: number = null
+        let sum = a + b
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      const sum = state.callStack[0].locals['sum'];
+      expect(sum.err).toBe(true);
+    });
+
+    it('first error wins when both operands have errors', () => {
+      const ast = parse(`
+        let a: number = null
+        let b: number = null
+        let sum = a + b
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      const sum = state.callStack[0].locals['sum'];
+      expect(sum.err).toBe(true);
+      // Should contain error from left operand
+      expect(sum.errDetails?.message).toContain('null');
+    });
+
+    it('error propagates through chain of operations', () => {
+      // Docs example: errors flow through naturally
+      const ast = parse(`
+        let a: number = null
+        let b = 10
+        let sum = a + b
+        let doubled = sum * 2
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      // doubled should have the propagated error
+      const doubled = state.callStack[0].locals['doubled'];
+      expect(doubled.err).toBe(true);
+      expect(doubled.errDetails?.message).toContain('null');
+    });
+
+    it('.err can be checked on final result of chain', () => {
+      const ast = parse(`
+        let a: number = null
+        let b = 10
+        let sum = a + b
+        let doubled = sum * 2
+        let hasError = doubled.err
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      expect(state.callStack[0].locals['hasError'].value).toBe(true);
+    });
+
+    it('no error when all values are valid', () => {
+      const ast = parse(`
+        let a = 5
+        let b = 10
+        let sum = a + b
+        let doubled = sum * 2
+        let hasError = doubled.err
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      expect(state.callStack[0].locals['doubled'].value).toBe(30);
+      expect(state.callStack[0].locals['hasError'].value).toBe(false);
+    });
+
+    it('error preserved when assigned to another variable', () => {
+      const ast = parse(`
+        let a: number = null
+        let b = a + 5
+        let c = b
+        let hasError = c.err
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      const c = state.callStack[0].locals['c'];
+      expect(c.err).toBe(true);
+      expect(state.callStack[0].locals['hasError'].value).toBe(true);
+    });
+  });
+
+  describe('JS interop - undefined to null normalization', () => {
+    it('normalizes ts block undefined return to null', () => {
+      const ast = parse(`
+        let result = ts() { return undefined }
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('awaiting_ts');
+
+      // Resume with undefined from TS
+      state = resumeWithTsResult(state, undefined);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      expect(state.callStack[0].locals['result'].value).toBe(null);
+    });
+
+    it('preserves actual null from ts block', () => {
+      const ast = parse(`
+        let result = ts() { return null }
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('awaiting_ts');
+
+      state = resumeWithTsResult(state, null);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      expect(state.callStack[0].locals['result'].value).toBe(null);
+    });
+
+    it('preserves other values from ts block', () => {
+      const ast = parse(`
+        let result = ts() { return 42 }
+      `);
+      let state = createInitialState(ast);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('awaiting_ts');
+
+      state = resumeWithTsResult(state, 42);
+      state = runUntilPause(state);
+
+      expect(state.status).toBe('completed');
+      expect(state.callStack[0].locals['result'].value).toBe(42);
+    });
+  });
+});

package/src/runtime/test/private-visibility.test.ts

@@ -0,0 +1,332 @@
+import { describe, it, expect } from 'bun:test';
+import { parse } from '../../parser/parse';
+import { createInitialState, currentFrame } from '../state';
+import { step } from '../step';
+import { buildLocalContext, buildGlobalContext, formatContextForAI } from '../context';
+
+describe('private variable visibility', () => {
+  describe('runtime state', () => {
+    it('stores isPrivate flag in VibeValue', () => {
+      const code = 'let private secret: text = "hidden"';
+      const ast = parse(code);
+      let state = createInitialState(ast);
+
+      // Execute until complete
+      while (state.status === 'running') {
+        state = step(state);
+      }
+
+      const frame = currentFrame(state);
+      expect(frame.locals['secret']).toBeDefined();
+      expect(frame.locals['secret'].value).toBe('hidden');
+      expect(frame.locals['secret'].isPrivate).toBe(true);
+    });
+
+    it('stores isPrivate flag in orderedEntries', () => {
+      const code = 'let private secret: text = "hidden"';
+      const ast = parse(code);
+      let state = createInitialState(ast);
+
+      while (state.status === 'running') {
+        state = step(state);
+      }
+
+      const frame = currentFrame(state);
+      const entry = frame.orderedEntries.find(
+        (e) => e.kind === 'variable' && e.name === 'secret'
+      );
+      expect(entry).toBeDefined();
+      expect(entry?.kind).toBe('variable');
+      if (entry?.kind === 'variable') {
+        expect(entry.isPrivate).toBe(true);
+      }
+    });
+
+    it('public variables do not have isPrivate flag', () => {
+      const code = 'let visible: text = "shown"';
+      const ast = parse(code);
+      let state = createInitialState(ast);
+
+      while (state.status === 'running') {
+        state = step(state);
+      }
+
+      const frame = currentFrame(state);
+      expect(frame.locals['visible']).toBeDefined();
+      expect(frame.locals['visible'].isPrivate).toBeUndefined();
+    });
+  });
+
+  describe('context filtering', () => {
+    it('filters private variables from local context', () => {
+      const code = `
+        let private secret: text = "hidden"
+        let visible: text = "shown"
+      `;
+      const ast = parse(code);
+      let state = createInitialState(ast);
+
+      while (state.status === 'running') {
+        state = step(state);
+      }
+
+      const context = buildLocalContext(state);
+      const varNames = context
+        .filter((e) => e.kind === 'variable')
+        .map((e) => (e as { name: string }).name);
+
+      expect(varNames).toContain('visible');
+      expect(varNames).not.toContain('secret');
+    });
+
+    it('filters private variables from global context', () => {
+      const code = `
+        let private secret: text = "hidden"
+        let visible: text = "shown"
+        const private API_KEY: text = "key"
+        const PUBLIC: text = "pub"
+      `;
+      const ast = parse(code);
+      let state = createInitialState(ast);
+
+      while (state.status === 'running') {
+        state = step(state);
+      }
+
+      const context = buildGlobalContext(state);
+      const varNames = context
+        .filter((e) => e.kind === 'variable')
+        .map((e) => (e as { name: string }).name);
+
+      expect(varNames).toContain('visible');
+      expect(varNames).toContain('PUBLIC');
+      expect(varNames).not.toContain('secret');
+      expect(varNames).not.toContain('API_KEY');
+    });
+
+    it('private variables still exist in runtime but hidden from context', () => {
+      const code = `
+        let private secret: text = "hidden"
+        let visible: text = "shown"
+      `;
+      const ast = parse(code);
+      let state = createInitialState(ast);
+
+      while (state.status === 'running') {
+        state = step(state);
+      }
+
+      const frame = currentFrame(state);
+
+      // Both exist in locals
+      expect(frame.locals['secret']).toBeDefined();
+      expect(frame.locals['visible']).toBeDefined();
+
+      // Only visible appears in context
+      const context = buildLocalContext(state);
+      expect(context.length).toBe(1);
+      expect((context[0] as { name: string }).name).toBe('visible');
+    });
+
+    it('filters private fields in destructuring from context', () => {
+      // For destructuring, we test that the orderedEntries correctly store isPrivate
+      const code = 'let private x: text = "a"';
+      const ast = parse(code);
+      let state = createInitialState(ast);
+
+      while (state.status === 'running') {
+        state = step(state);
+      }
+
+      const frame = currentFrame(state);
+      const entry = frame.orderedEntries[0];
+      expect(entry.kind).toBe('variable');
+      if (entry.kind === 'variable') {
+        expect(entry.name).toBe('x');
+        expect(entry.isPrivate).toBe(true);
+      }
+
+      // Verify filtered from context
+      const context = buildLocalContext(state);
+      expect(context.length).toBe(0);
+    });
+  });
+
+  describe('mixed visibility scenarios', () => {
+    it('handles multiple private and public vars correctly', () => {
+      const code = `
+        let private a: text = "1"
+        let b: text = "2"
+        let private c: text = "3"
+        let d: text = "4"
+        let private e: text = "5"
+      `;
+      const ast = parse(code);
+      let state = createInitialState(ast);
+
+      while (state.status === 'running') {
+        state = step(state);
+      }
+
+      const context = buildLocalContext(state);
+      const varNames = context
+        .filter((e) => e.kind === 'variable')
+        .map((e) => (e as { name: string }).name);
+
+      // Only b and d should be visible
+      expect(varNames).toEqual(['b', 'd']);
+    });
+  });
+
+  describe('destructuring with mixed visibility', () => {
+    it('simulates destructuring: private x is hidden, public y is visible', () => {
+      // Destructuring requires a do/vibe expression which needs AI.
+      // We simulate the result by manually creating variables as if
+      // `let {private x: text, y: number} = do "..." model` had executed.
+
+      const code = 'let placeholder = 0';  // Need some code to initialize state
+      const ast = parse(code);
+      let state = createInitialState(ast);
+
+      // Execute to get initial state set up
+      while (state.status === 'running') {
+        state = step(state);
+      }
+
+      // Now manually add variables as if destructuring had happened
+      const frame = currentFrame(state);
+
+      // Simulate: let {private x: text, y: number} = ...
+      // x is private (isPrivate: true), y is public (no isPrivate)
+      const newLocals = {
+        ...frame.locals,
+        x: {
+          value: 'secret-value',
+          err: false,
+          errDetails: null,
+          toolCalls: [],
+          isConst: false,
+          typeAnnotation: 'text' as const,
+          source: 'ai' as const,
+          isPrivate: true,  // x is private
+        },
+        y: {
+          value: 42,
+          err: false,
+          errDetails: null,
+          toolCalls: [],
+          isConst: false,
+          typeAnnotation: 'number' as const,
+          source: 'ai' as const,
+          // y has no isPrivate (public)
+        },
+      };
+
+      const newOrderedEntries = [
+        ...frame.orderedEntries,
+        {
+          kind: 'variable' as const,
+          name: 'x',
+          value: 'secret-value',
+          type: 'text',
+          isConst: false,
+          source: 'ai' as const,
+          isPrivate: true,  // x is private
+        },
+        {
+          kind: 'variable' as const,
+          name: 'y',
+          value: 42,
+          type: 'number',
+          isConst: false,
+          source: 'ai' as const,
+          // y has no isPrivate (public)
+        },
+      ];
+
+      state = {
+        ...state,
+        callStack: [
+          ...state.callStack.slice(0, -1),
+          { ...frame, locals: newLocals, orderedEntries: newOrderedEntries },
+        ],
+      };
+
+      // Verify both exist in runtime
+      const updatedFrame = currentFrame(state);
+      expect(updatedFrame.locals['x']).toBeDefined();
+      expect(updatedFrame.locals['x'].value).toBe('secret-value');
+      expect(updatedFrame.locals['x'].isPrivate).toBe(true);
+
+      expect(updatedFrame.locals['y']).toBeDefined();
+      expect(updatedFrame.locals['y'].value).toBe(42);
+      expect(updatedFrame.locals['y'].isPrivate).toBeUndefined();
+
+      // Verify LOCAL context filtering: x hidden, y visible
+      const localContext = buildLocalContext(state);
+      const localVarNames = localContext
+        .filter((e) => e.kind === 'variable')
+        .map((e) => (e as { name: string }).name);
+
+      expect(localVarNames).toContain('y');
+      expect(localVarNames).not.toContain('x');
+      expect(localVarNames).toContain('placeholder');  // public
+
+      // Verify GLOBAL context filtering: x hidden, y visible
+      const globalContext = buildGlobalContext(state);
+      const globalVarNames = globalContext
+        .filter((e) => e.kind === 'variable')
+        .map((e) => (e as { name: string }).name);
+
+      expect(globalVarNames).toContain('y');
+      expect(globalVarNames).not.toContain('x');
+      expect(globalVarNames).toContain('placeholder');  // public
+
+      // Verify FORMATTED TEXT doesn't contain private variable
+      // This is the actual text sent to AI
+      const formattedLocal = formatContextForAI(localContext);
+      expect(formattedLocal.text).toContain('y');
+      expect(formattedLocal.text).not.toContain('secret-value');  // x's value
+      expect(formattedLocal.text).not.toMatch(/\bx\b.*secret/);   // x: secret pattern
+
+      const formattedGlobal = formatContextForAI(globalContext);
+      expect(formattedGlobal.text).toContain('y');
+      expect(formattedGlobal.text).not.toContain('secret-value');
+      expect(formattedGlobal.text).not.toMatch(/\bx\b.*secret/);
+    });
+  });
+
+  describe('formatted context text', () => {
+    it('private variables do not appear in AI context text', () => {
+      const code = `
+        let private secret: text = "super-secret-password"
+        let visible: text = "public-data"
+      `;
+      const ast = parse(code);
+      let state = createInitialState(ast);
+
+      while (state.status === 'running') {
+        state = step(state);
+      }
+
+      const localContext = buildLocalContext(state);
+      const globalContext = buildGlobalContext(state);
+
+      // Format context as it would be sent to AI
+      const formattedLocal = formatContextForAI(localContext);
+      const formattedGlobal = formatContextForAI(globalContext);
+
+      // Visible variable should appear in text
+      expect(formattedLocal.text).toContain('visible');
+      expect(formattedLocal.text).toContain('public-data');
+      expect(formattedGlobal.text).toContain('visible');
+      expect(formattedGlobal.text).toContain('public-data');
+
+      // Private variable should NOT appear in text
+      expect(formattedLocal.text).not.toContain('secret');
+      expect(formattedLocal.text).not.toContain('super-secret-password');
+      expect(formattedGlobal.text).not.toContain('secret');
+      expect(formattedGlobal.text).not.toContain('super-secret-password');
+    });
+  });
+});