luca 3.0.0 → 3.0.2

package/test/vm-context.test.ts

@@ -1,146 +0,0 @@
-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

@@ -1,213 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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
-  )
-})