luca 2.0.0 → 3.0.0

package/test/vm-context.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'bun:test'
+import { NodeContainer } from '../src/node/container'
+
+/**
+ * These tests verify the VM context preservation behavior that `luca run`
+ * depends on for markdown execution. When running sequential code blocks
+ * in a shared context, variables defined in earlier blocks must be accessible
+ * in later blocks — as long as the blocks don't use top-level await (which
+ * wraps code in an async IIFE and isolates the scope).
+ */
+describe('VM context preservation across sequential runs', () => {
+	it('preserves const declarations across runs without await', async () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+		const shared = vm.createContext({})
+
+		await vm.run('const x = 42', shared)
+		const result = await vm.run('x', shared)
+
+		expect(result).toBe(42)
+	})
+
+	it('preserves let declarations across runs without await', async () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+		const shared = vm.createContext({})
+
+		await vm.run('let count = 0', shared)
+		await vm.run('count += 10', shared)
+		const result = await vm.run('count', shared)
+
+		expect(result).toBe(10)
+	})
+
+	it('preserves function declarations across runs', async () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+		const shared = vm.createContext({})
+
+		await vm.run('function double(n) { return n * 2 }', shared)
+		const result = await vm.run('double(21)', shared)
+
+		expect(result).toBe(42)
+	})
+
+	it('preserves arrow functions assigned to const', async () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+		const shared = vm.createContext({})
+
+		await vm.run('const greet = (name) => `hello ${name}`', shared)
+		const result = await vm.run('greet("world")', shared)
+
+		expect(result).toBe('hello world')
+	})
+
+	it('preserves objects and allows mutation across runs', async () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+		const shared = vm.createContext({})
+
+		await vm.run('const data = { items: [] }', shared)
+		await vm.run('data.items.push("a", "b")', shared)
+		await vm.run('data.items.push("c")', shared)
+		const result = await vm.run('data.items', shared)
+
+		expect(result).toEqual(['a', 'b', 'c'])
+	})
+
+	it('preserves class declarations across runs', async () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+		const shared = vm.createContext({})
+
+		await vm.run('class Counter { constructor() { this.n = 0 } inc() { this.n++ } }', shared)
+		await vm.run('const counter = new Counter(); counter.inc(); counter.inc()', shared)
+		const result = await vm.run('counter.n', shared)
+
+		expect(result).toBe(2)
+	})
+
+	it('later blocks can compose values from earlier blocks', async () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+		const shared = vm.createContext({})
+
+		await vm.run('const firstName = "Jane"', shared)
+		await vm.run('const lastName = "Doe"', shared)
+		await vm.run('const fullName = `${firstName} ${lastName}`', shared)
+		const result = await vm.run('fullName', shared)
+
+		expect(result).toBe('Jane Doe')
+	})
+
+	it('top-level await blocks lose const/let scope (known limitation)', async () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+		const shared = vm.createContext({})
+
+		// This block has await, so it gets wrapped in (async () => { ... })()
+		// The const is scoped to that IIFE and doesn't leak to the shared context
+		await vm.run('const val = await Promise.resolve(99)', shared)
+		const result = await vm.run('typeof val', shared)
+
+		expect(result).toBe('undefined')
+	})
+
+	it('top-level await blocks can share state via pre-existing context properties', async () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+		const shared = vm.createContext({ result: null })
+
+		// Assigning to an existing context property works even inside the IIFE
+		await vm.run('result = await Promise.resolve("async value")', shared)
+		const value = await vm.run('result', shared)
+
+		expect(value).toBe('async value')
+	})
+})
+
+describe('VM wrapTopLevelAwait', () => {
+	it('does not wrap code without await', () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+
+		const code = 'const x = 42'
+		expect(vm.wrapTopLevelAwait(code)).toBe(code)
+	})
+
+	it('wraps code containing await in an async IIFE', () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+
+		const wrapped = vm.wrapTopLevelAwait('const x = await fetch("http://example.com")')
+		expect(wrapped).toContain('async')
+		expect(wrapped).toContain('await fetch')
+	})
+
+	it('does not wrap code already in an async function', () => {
+		const c = new NodeContainer()
+		const vm = c.feature('vm')
+
+		const code = 'async function go() { await fetch("http://example.com") }'
+		expect(vm.wrapTopLevelAwait(code)).toBe(code)
+	})
+})

package/test/vm-loadmodule.test.ts

@@ -0,0 +1,213 @@
+import { describe, it, expect } from 'bun:test'
+import { NodeContainer } from '../src/node/container'
+
+/**
+ * Tests for the vm.loadModule pipeline: TypeScript source → esmToCjs → performSync → exports.
+ *
+ * These tests exercise the transpiler+VM execution path in isolation by running
+ * TypeScript code strings directly through transpiler.transformSync + vm.performSync,
+ * exactly as loadModule does internally.
+ */
+
+function runModule(c: NodeContainer, ts: string, ctx: Record<string, any> = {}): Record<string, any> {
+	const transpiler = c.feature('transpiler')
+	const vm = c.feature('vm')
+	const { code } = transpiler.transformSync(ts, { format: 'cjs' })
+	const sharedExports = {}
+	const { context } = vm.performSync(code, {
+		require: (id: string) => require(id),
+		exports: sharedExports,
+		module: { exports: sharedExports },
+		console,
+		...ctx,
+	})
+	return context.module?.exports || context.exports || {}
+}
+
+describe('vm.loadModule pipeline', () => {
+	describe('export const / let / var', () => {
+		it('exports a const', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `export const x = 42`)
+			expect(exports.x).toBe(42)
+		})
+
+		it('exports a let', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `export let name = 'hello'`)
+			expect(exports.name).toBe('hello')
+		})
+
+		it('exports multiple consts', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `
+				export const a = 1
+				export const b = 2
+				export const c = 3
+			`)
+			expect(exports.a).toBe(1)
+			expect(exports.b).toBe(2)
+			expect(exports.c).toBe(3)
+		})
+
+		it('exports a const object', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `
+				export const schemas = { rg: 'search', ls: 'list' }
+			`)
+			expect(exports.schemas).toEqual({ rg: 'search', ls: 'list' })
+		})
+	})
+
+	describe('export function', () => {
+		it('exports a named function', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `
+				export function greet(name: string): string {
+					return 'hello ' + name
+				}
+			`)
+			expect(typeof exports.greet).toBe('function')
+			expect(exports.greet('world')).toBe('hello world')
+		})
+
+		it('exports an async function', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `
+				export async function fetchData(): Promise<string> {
+					return 'data'
+				}
+			`)
+			expect(typeof exports.fetchData).toBe('function')
+		})
+
+		it('exports multiple functions', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `
+				export function add(a: number, b: number) { return a + b }
+				export function multiply(a: number, b: number) { return a * b }
+			`)
+			expect(exports.add(2, 3)).toBe(5)
+			expect(exports.multiply(2, 3)).toBe(6)
+		})
+	})
+
+	describe('export { ... }', () => {
+		it('exports from a named export block', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `
+				const foo = 'foo'
+				const bar = 42
+				export { foo, bar }
+			`)
+			expect(exports.foo).toBe('foo')
+			expect(exports.bar).toBe(42)
+		})
+
+		it('exports with renaming', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `
+				const internal = 'value'
+				export { internal as external }
+			`)
+			expect(exports.external).toBe('value')
+			expect(exports.internal).toBeUndefined()
+		})
+	})
+
+	describe('export default', () => {
+		it('exports a default value', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `export default 99`)
+			expect(exports.default).toBe(99)
+		})
+
+		it('exports a default object', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `export default { key: 'value' }`)
+			expect(exports.default).toEqual({ key: 'value' })
+		})
+	})
+
+	describe('TypeScript features', () => {
+		it('strips type annotations', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `
+				export function identity<T>(value: T): T {
+					return value
+				}
+			`)
+			expect(exports.identity('test')).toBe('test')
+			expect(exports.identity(42)).toBe(42)
+		})
+
+		it('strips import type statements', () => {
+			const c = new NodeContainer()
+			// import type should be stripped entirely — no runtime require
+			const exports = runModule(c, `
+				import type { SomeType } from 'some-module'
+				export const x = 1
+			`)
+			expect(exports.x).toBe(1)
+		})
+
+		it('strips declare global blocks', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `
+				declare global {
+					var container: any
+				}
+				export const answer = 42
+			`)
+			expect(exports.answer).toBe(42)
+		})
+	})
+
+	describe('context injection', () => {
+		it('injected context variables are accessible in module code', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `
+				export function getGreeting(): string {
+					return greeting + ' world'
+				}
+			`, { greeting: 'hello' })
+			expect(exports.getGreeting()).toBe('hello world')
+		})
+
+		it('injected functions are callable from exported functions', () => {
+			const c = new NodeContainer()
+			const log: string[] = []
+			const exports = runModule(c, `
+				export function run() {
+					record('called')
+				}
+			`, { record: (s: string) => log.push(s) })
+			exports.run()
+			expect(log).toEqual(['called'])
+		})
+	})
+
+	describe('mixed exports (tools.ts pattern)', () => {
+		it('handles the schemas + named functions pattern used by assistant tools', () => {
+			const c = new NodeContainer()
+			const exports = runModule(c, `
+				export const schemas = {
+					echo: { description: 'echo a value', properties: { text: {} } }
+				}
+
+				export function echo({ text }: { text: string }): string {
+					return text
+				}
+
+				export async function asyncOp(): Promise<string> {
+					return 'done'
+				}
+			`)
+			expect(exports.schemas).toBeDefined()
+			expect(exports.schemas.echo.description).toBe('echo a value')
+			expect(typeof exports.echo).toBe('function')
+			expect(exports.echo({ text: 'hi' })).toBe('hi')
+			expect(typeof exports.asyncOp).toBe('function')
+		})
+	})
+})

package/test/websocket-ask.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect, afterAll } from 'bun:test'
+import { NodeContainer } from '../src/node/container'
+
+describe('WebSocket ask/reply protocol', () => {
+  const container = new NodeContainer()
+  const server = container.server('websocket', { json: true })
+  let clientWsOnServer: any
+
+  afterAll(async () => {
+    try { server.connections.forEach((ws: any) => ws.close?.()) } catch {}
+    try { await server.stop() } catch {}
+  })
+
+  it('setup: start server and connect client', async () => {
+    const connPromise = new Promise<any>((resolve) => {
+      server.on('connection', resolve)
+    })
+
+    server.on('message', (data: any) => {
+      if (data.type === 'greet') {
+        data.reply({ greeting: `hello ${data.data.name}` })
+      }
+      if (data.type === 'fail') {
+        data.replyError('something went wrong')
+      }
+    })
+
+    await server.start({ port: 19880 })
+
+    // Use bun's native WebSocket as the client
+    const ws = new WebSocket('ws://localhost:19880')
+    await new Promise<void>((resolve, reject) => {
+      ws.onopen = () => resolve()
+      ws.onerror = (e) => reject(e)
+    })
+
+    clientWsOnServer = await connPromise
+    expect(clientWsOnServer).toBeDefined()
+
+    // Wire up the client to handle server-initiated asks
+    ws.onmessage = (event: any) => {
+      const msg = JSON.parse(event.data)
+      if (msg.requestId && msg.type === 'identify') {
+        ws.send(JSON.stringify({ replyTo: msg.requestId, data: { role: 'worker' } }))
+      }
+    }
+
+    // Stash ws for other tests
+    ;(globalThis as any).__testWs = ws
+  })
+
+  it('client.ask() sends a request and resolves with the server reply', async () => {
+    const ws = (globalThis as any).__testWs as WebSocket
+
+    // Manually implement the client-side ask protocol
+    const requestId = container.utils.uuid()
+    const result = await new Promise<any>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('timeout')), 5000)
+      const handler = (event: any) => {
+        const msg = JSON.parse(event.data)
+        if (msg.replyTo === requestId) {
+          clearTimeout(timer)
+          ws.removeEventListener('message', handler)
+          if (msg.error) reject(new Error(msg.error))
+          else resolve(msg.data)
+        }
+      }
+      ws.addEventListener('message', handler)
+      ws.send(JSON.stringify({ type: 'greet', data: { name: 'luca' }, requestId }))
+    })
+
+    expect(result).toEqual({ greeting: 'hello luca' })
+  })
+
+  it('server.ask() sends a request and resolves with the client reply', async () => {
+    const result = await server.ask(clientWsOnServer, 'identify')
+    expect(result).toEqual({ role: 'worker' })
+  })
+
+  it('ask() rejects with error when reply contains error', async () => {
+    const ws = (globalThis as any).__testWs as WebSocket
+
+    const requestId = container.utils.uuid()
+    const promise = new Promise<any>((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('timeout')), 5000)
+      const handler = (event: any) => {
+        const msg = JSON.parse(event.data)
+        if (msg.replyTo === requestId) {
+          clearTimeout(timer)
+          ws.removeEventListener('message', handler)
+          if (msg.error) reject(new Error(msg.error))
+          else resolve(msg.data)
+        }
+      }
+      ws.addEventListener('message', handler)
+      ws.send(JSON.stringify({ type: 'fail', requestId }))
+    })
+
+    await expect(promise).rejects.toThrow('something went wrong')
+  })
+})

package/test-integration/assistant.test.ts

@@ -0,0 +1,138 @@
+import {
+  requireEnv,
+  describeWithRequirements,
+  createAGIContainer,
+  API_TIMEOUT,
+} from './helpers'
+import type { AGIContainer } from '../src/agi/container.server'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from 'fs'
+import { join } from 'path'
+import { tmpdir } from 'os'
+
+const openaiKey = requireEnv('OPENAI_API_KEY')
+
+describeWithRequirements('Assistant Integration', [openaiKey], () => {
+  let container: AGIContainer
+  let assistantDir: string
+  let tempDir: string
+
+  beforeAll(() => {
+    tempDir = realpathSync(mkdtempSync(join(tmpdir(), 'luca-assistant-test-')))
+    assistantDir = join(tempDir, 'assistants', 'test-helper')
+    mkdirSync(assistantDir, { recursive: true })
+
+    writeFileSync(
+      join(assistantDir, 'CORE.md'),
+      'You are a test assistant. Always reply with short, direct answers. If asked for your name, say "TestBot".'
+    )
+
+    container = createAGIContainer({ cwd: tempDir })
+  })
+
+  afterAll(() => {
+    rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  it(
+    'creates assistant and ask() returns a response',
+    async () => {
+      const assistant = container.feature('assistant', {
+        folder: assistantDir,
+        model: 'gpt-4o-mini',
+        historyMode: 'lifecycle',
+      })
+
+      await assistant.start()
+      expect(assistant.isStarted).toBe(true)
+
+      const reply = await assistant.ask('What is your name?')
+      expect(typeof reply).toBe('string')
+      expect(reply.length).toBeGreaterThan(0)
+      expect(reply).toContain('TestBot')
+    },
+    API_TIMEOUT
+  )
+
+  it(
+    'system prompt is loaded from CORE.md',
+    async () => {
+      const assistant = container.feature('assistant', {
+        folder: assistantDir,
+        model: 'gpt-4o-mini',
+        historyMode: 'lifecycle',
+      })
+
+      await assistant.start()
+      expect(assistant.systemPrompt).toContain('test assistant')
+      expect(assistant.systemPrompt).toContain('TestBot')
+    },
+    API_TIMEOUT
+  )
+
+  it(
+    'events fire during conversation',
+    async () => {
+      const events: string[] = []
+      const assistant = container.feature('assistant', {
+        folder: assistantDir,
+        model: 'gpt-4o-mini',
+        historyMode: 'lifecycle',
+      })
+
+      assistant.on('started', () => events.push('started'))
+      assistant.on('turnStart', () => events.push('turnStart'))
+      assistant.on('turnEnd', () => events.push('turnEnd'))
+      assistant.on('response', () => events.push('response'))
+
+      await assistant.start()
+      expect(events).toContain('started')
+
+      await assistant.ask('Hello')
+      expect(events).toContain('turnStart')
+      expect(events).toContain('turnEnd')
+      expect(events).toContain('response')
+    },
+    API_TIMEOUT
+  )
+
+  it(
+    'conversation state accumulates messages',
+    async () => {
+      const assistant = container.feature('assistant', {
+        folder: assistantDir,
+        model: 'gpt-4o-mini',
+        historyMode: 'lifecycle',
+      })
+
+      await assistant.start()
+      await assistant.ask('Remember: the secret code is 42.')
+      await assistant.ask('What is the secret code?')
+
+      const messages = assistant.messages
+      expect(messages.length).toBeGreaterThanOrEqual(5) // system + 2 user + 2 assistant
+    },
+    API_TIMEOUT
+  )
+
+  it(
+    'addTool and removeTool work at runtime',
+    async () => {
+      const assistant = container.feature('assistant', {
+        folder: assistantDir,
+        model: 'gpt-4o-mini',
+        historyMode: 'lifecycle',
+      })
+
+      await assistant.start()
+
+      const toolFn = async (args: { x: number }) => String(args.x * 2)
+      assistant.addTool(toolFn, container.z.object({ x: container.z.number() }).describe('Doubles a number'))
+
+      expect(assistant.tools).toHaveProperty('toolFn')
+
+      assistant.removeTool('toolFn')
+      expect(assistant.tools).not.toHaveProperty('toolFn')
+    },
+    API_TIMEOUT
+  )
+})