@soederpop/luca 0.1.0 → 0.1.2

package/src/introspection/generated.web.ts

@@ -1,7 +1,7 @@
 import { setBuildTimeData, setContainerBuildTimeData } from './index.js';
 
 // Auto-generated introspection registry data
-// Generated at: 2026-03-28T05:59:16.310Z
+// Generated at: 2026-03-30T06:52:54.962Z
 
 setBuildTimeData('features.containerLink', {
   "id": "features.containerLink",

package/src/node/features/figlet-fonts.ts

@@ -294,7 +294,10 @@ import f292 from "figlet/importable-fonts/Whimsy.js";
 import f293 from "figlet/importable-fonts/Wow.js";
 import f294 from "figlet/importable-fonts/miniwi.js";
 
-import figlet from "figlet/lib/figlet.js";
+// Use the browser (core) subpath — filesystem-free, works in compiled binaries.
+// figlet 1.11.0 replaced lib/ with dist/ and added an exports map; "./browser" is the stable subpath.
+// @ts-ignore — figlet/browser exists at runtime via the package exports map
+import figlet from "figlet/browser";
 
 // Register all fonts with figlet (filesystem-free, works in compiled binaries)
 figlet.parseFont("1Row", f0);

package/src/node/features/transpiler.ts

@@ -18,7 +18,9 @@ export interface TransformResult {
  * so the code can run in a vm context that provides `require`.
  */
 function esmToCjs(code: string): string {
-  return code
+  const exportedNames: string[] = []
+
+  let result = code
     // import Foo, { bar, baz } from 'x' → const Foo = require('x').default ?? require('x'); const { bar, baz } = require('x')
     .replace(/^import\s+(\w+)\s*,\s*\{([^}]+)\}\s+from\s+(['"][^'"]+['"])\s*;?$/gm,
       'const $1 = require($3).default ?? require($3); const {$2} = require($3);')
@@ -39,14 +41,37 @@ function esmToCjs(code: string): string {
     // export { a, b } from 'x' → Object.assign(module.exports, require('x'))  (re-exports)
     .replace(/^export\s+\{[^}]*\}\s+from\s+(['"][^'"]+['"])\s*;?$/gm,
       'Object.assign(module.exports, require($1));')
-    // export { ... } → strip (vars already in scope)
-    .replace(/^export\s+\{[^}]*\}\s*;?$/gm, '')
-    // export const/let/var → const/let/var
-    .replace(/^export\s+(const|let|var)\s+/gm, '$1 ')
-    // export function → function (keep declaration, strip export keyword)
-    .replace(/^export\s+(function|class)\s+/gm, '$1 ')
-    // export async function → async function
-    .replace(/^export\s+(async\s+function)\s+/gm, '$1 ')
+    // export { a, b as c } → exports.a = a; exports.c = b;
+    .replace(/^export\s+\{([^}]*)\}\s*;?$/gm, (_match, body: string) => {
+      return body.split(',').map(s => {
+        const parts = s.trim().split(/\s+as\s+/)
+        const local = parts[0].trim()
+        const exported = (parts[1] || parts[0]).trim()
+        return local ? `exports['${exported}'] = ${local};` : ''
+      }).filter(Boolean).join(' ')
+    })
+    // export const/let/var NAME → const/let/var NAME (track for deferred export)
+    .replace(/^export\s+(const|let|var)\s+(\w+)/gm, (_match, decl: string, name: string) => {
+      exportedNames.push(name)
+      return `${decl} ${name}`
+    })
+    // export function NAME / export class NAME → function/class NAME (track for deferred export)
+    .replace(/^export\s+(function|class)\s+(\w+)/gm, (_match, type: string, name: string) => {
+      exportedNames.push(name)
+      return `${type} ${name}`
+    })
+    // export async function NAME → async function NAME (track for deferred export)
+    .replace(/^export\s+(async\s+function)\s+(\w+)/gm, (_match, type: string, name: string) => {
+      exportedNames.push(name)
+      return `${type} ${name}`
+    })
+
+  // Append exports for all tracked named exports
+  if (exportedNames.length > 0) {
+    result += '\n' + exportedNames.map(n => `exports['${n}'] = ${n};`).join('\n')
+  }
+
+  return result
 }
 
 /**

package/src/node/features/vm.ts

@@ -392,10 +392,11 @@ export class VM<
     const raw = fs.readFile(filePath)
     const { code } = this.container.feature('transpiler').transformSync(raw, { format: 'cjs' })
 
+    const sharedExports = {}
     const { context } = this.performSync(code, {
       require: this.createRequireFor(filePath),
-      exports: {},
-      module: { exports: {} },
+      exports: sharedExports,
+      module: { exports: sharedExports },
       console,
       setTimeout,
       setInterval,

package/src/python/generated.ts

@@ -1,5 +1,5 @@
 // Auto-generated Python bridge script
-// Generated at: 2026-03-28T05:59:19.077Z
+// Generated at: 2026-03-30T06:52:57.841Z
 // Source: src/python/bridge.py
 //
 // Do not edit manually. Run: luca build-python-bridge

package/src/scaffolds/generated.ts

@@ -1,5 +1,5 @@
 // Auto-generated scaffold and MCP readme content
-// Generated at: 2026-03-28T05:59:17.268Z
+// Generated at: 2026-03-30T06:52:56.013Z
 // Source: docs/scaffolds/*.md, docs/examples/assistant/, and docs/mcp/readme.md
 //
 // Do not edit manually. Run: luca build-scaffolds

package/test/assistant.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect, beforeEach } from 'bun:test'
+import { AGIContainer } from '../src/agi/container.server'
+
+describe('Assistant', () => {
+	let container: AGIContainer
+
+	beforeEach(() => {
+		container = new AGIContainer()
+	})
+
+	describe('codingAssistant', () => {
+		it('loads a non-empty system prompt from CORE.md', () => {
+			const assistant = container.feature('assistant', { folder: 'assistants/codingAssistant' })
+			expect(assistant.systemPrompt.length).toBeGreaterThan(0)
+			expect(assistant.systemPrompt).toContain('coding assistant')
+		})
+
+		it('loads tools from tools.ts via the VM', () => {
+			const assistant = container.feature('assistant', { folder: 'assistants/codingAssistant' })
+			const tools = assistant.availableTools
+			expect(tools).toContain('rg')
+			expect(tools).toContain('ls')
+			expect(tools).toContain('cat')
+			expect(tools).toContain('pwd')
+			expect(tools.length).toBeGreaterThan(0)
+		})
+
+		it('tools have descriptions and parameter schemas', () => {
+			const assistant = container.feature('assistant', { folder: 'assistants/codingAssistant' })
+			const { rg, ls, cat } = assistant.tools
+			expect(rg.description.length).toBeGreaterThan(0)
+			expect(rg.parameters.type).toBe('object')
+			expect(rg.parameters.properties).toHaveProperty('args')
+			expect(ls.parameters.properties).toHaveProperty('args')
+			expect(cat.parameters.properties).toHaveProperty('args')
+		})
+
+		it('loads hooks from hooks.ts via the VM', () => {
+			const assistant = container.feature('assistant', { folder: 'assistants/codingAssistant' })
+			const hooks = assistant.state.get('hooks') as Record<string, Function>
+			expect(hooks).toBeDefined()
+			expect(typeof hooks.started).toBe('function')
+		})
+
+		it('hooks fire when the assistant starts', async () => {
+			const assistant = container.feature('assistant', {
+				folder: 'assistants/codingAssistant',
+				local: true,
+				model: 'qwen/qwen3-8b',
+			})
+
+			// bindHooksToEvents emits 'hookFired' with the event name each time a hook runs
+			const fired: string[] = []
+			assistant.on('hookFired', (eventName: string) => { fired.push(eventName) })
+
+			await assistant.start()
+			expect(fired).toContain('started')
+		})
+
+		it('tools are wired into the conversation after start', async () => {
+			const assistant = container.feature('assistant', {
+				folder: 'assistants/codingAssistant',
+				local: true,
+				model: 'qwen/qwen3-8b',
+			})
+			await assistant.start()
+			const convTools = assistant.conversation.tools
+			expect(Object.keys(convTools)).toContain('rg')
+			expect(Object.keys(convTools)).toContain('ls')
+		})
+	})
+})

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')
+		})
+	})
+})