@soederpop/luca 0.1.1 → 0.1.3

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/tsconfig.build.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "declarationMap": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx"]
+}

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     // Environment setup & latest features
-    "lib": ["ESNext"],
+    "lib": ["ESNext", "dom", "dom.iterable"],
     "target": "ESNext",
     "module": "Preserve",
     "moduleDetection": "force",

package/scripts/examples/telegram-ink-ui.ts

@@ -1,302 +0,0 @@
-import { spawn, type ChildProcessByStdio } from 'node:child_process'
-import type { Readable } from 'node:stream'
-import path from 'node:path'
-import { existsSync } from 'node:fs'
-import container from '@soederpop/luca/node'
-import { resolveAnimation } from './animations'
-
-type ProcessStatus = 'idle' | 'running' | 'exited' | 'error'
-
-const MAX_OUTPUT_LINES = 220
-const DEFAULT_ANIMATION = process.env.LUCA_BOT_ANIMATION || 'neonPulse'
-
-function splitLines(input: string): string[] {
-  return input.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n')
-}
-
-function pushChunk(target: string[], chunk: string, label?: string) {
-  const lines = splitLines(chunk).filter((line) => line.length > 0)
-  for (const line of lines) {
-    target.push(label ? `[${label}] ${line}` : line)
-  }
-  if (target.length > MAX_OUTPUT_LINES) {
-    target.splice(0, target.length - MAX_OUTPUT_LINES)
-  }
-}
-
-function resolveTelegramScriptPath(): string | null {
-  const fromEnv = process.env.LUCA_TELEGRAM_SCRIPT?.trim()
-  const candidates = [
-    fromEnv,
-    'scripts/examples/telegram.ts',
-    'scripts/examples/telegram-bot.ts',
-    'scripts/telegram.ts',
-    'scripts/telegram-bot.ts',
-  ].filter(Boolean) as string[]
-
-  for (const candidate of candidates) {
-    const resolved = path.isAbsolute(candidate) ? candidate : path.resolve(process.cwd(), candidate)
-    if (existsSync(resolved)) return resolved
-  }
-
-  return null
-}
-
-function createBotCommand(): { command: string; args: string[]; source: string } {
-  const explicitCommand = process.env.LUCA_TELEGRAM_COMMAND?.trim()
-  if (explicitCommand) {
-    return {
-      command: '/bin/sh',
-      args: ['-lc', explicitCommand],
-      source: explicitCommand,
-    }
-  }
-
-  const scriptPath = resolveTelegramScriptPath()
-  if (!scriptPath) {
-    const helpLines = [
-      'No telegram script found.',
-      'Set LUCA_TELEGRAM_SCRIPT to your script path, e.g.:',
-      '  LUCA_TELEGRAM_SCRIPT=scripts/my-telegram.ts',
-      'Or set LUCA_TELEGRAM_COMMAND for a custom run command.',
-    ]
-    const helpCommand = `${helpLines.map((line) => `echo "${line.replace(/"/g, '\\"')}"`).join('; ')}; sleep 9999`
-
-    return {
-      command: '/bin/sh',
-      args: ['-lc', helpCommand],
-      source: 'waiting-for-config',
-    }
-  }
-
-  return {
-    command: 'bun',
-    args: ['run', scriptPath],
-    source: scriptPath,
-  }
-}
-
-async function main() {
-  const ink = container.feature('ink', { enable: true, patchConsole: true })
-  await ink.loadModules()
-
-  const React = ink.React
-  const h = React.createElement
-  const { useEffect, useMemo, useRef, useState } = React
-
-  const { Box, Text } = ink.components
-  const { useApp, useInput, useStdout, useStdin } = ink.hooks
-
-  const animation = resolveAnimation(DEFAULT_ANIMATION)
-  const botProcess = createBotCommand()
-
-  function useAnimationFrame(frames: string[], fps: number): string {
-    const [index, setIndex] = useState(0)
-
-    useEffect(() => {
-      const safeFps = Math.max(1, fps)
-      const interval = setInterval(() => {
-        setIndex((prev: number) => (prev + 1) % frames.length)
-      }, Math.floor(1000 / safeFps))
-      return () => clearInterval(interval)
-    }, [fps, frames.length])
-
-    return frames[index] || ''
-  }
-
-  function frameLines(frame: string, maxWidth: number): string[] {
-    return splitLines(frame).map((line) => (line.length > maxWidth ? line.slice(0, maxWidth - 1) + '.' : line))
-  }
-
-  function App() {
-    const { stdout } = useStdout()
-    const { isRawModeSupported } = useStdin()
-    const { exit } = useApp()
-
-    const [status, setStatus] = useState<ProcessStatus>('idle')
-    const [exitCode, setExitCode] = useState<number | null>(null)
-    const [startedAt, setStartedAt] = useState<number | null>(null)
-    const [outputLines, setOutputLines] = useState<string[]>([])
-
-    const processRef = useRef<ChildProcessByStdio<null, Readable, Readable> | null>(null)
-    const bufferRef = useRef({ stdout: '', stderr: '' })
-
-    const cols = stdout.columns || 120
-    const leftWidth = Math.max(38, Math.floor(cols * 0.42))
-    const rightWidth = Math.max(42, cols - leftWidth - 5)
-
-    const currentFrame = useAnimationFrame(animation.frames, animation.fps)
-
-    const uptime = useMemo(() => {
-      if (!startedAt || status === 'idle') return '00:00'
-      const secs = Math.floor((Date.now() - startedAt) / 1000)
-      const mm = Math.floor(secs / 60)
-      const ss = secs % 60
-      return `${String(mm).padStart(2, '0')}:${String(ss).padStart(2, '0')}`
-    }, [startedAt, status, outputLines.length])
-
-    useEffect(() => {
-      const run = () => {
-        setStatus('running')
-        setStartedAt(Date.now())
-
-        const child = spawn(botProcess.command, botProcess.args, {
-          cwd: process.cwd(),
-          env: process.env,
-          stdio: ['ignore', 'pipe', 'pipe'],
-        })
-
-        processRef.current = child
-
-        const flushOutput = (kind: 'stdout' | 'stderr', chunk: Buffer) => {
-          const key = kind
-          const prior = bufferRef.current[key]
-          const merged = prior + chunk.toString('utf8')
-          const lines = merged.split(/\r?\n/)
-          bufferRef.current[key] = lines.pop() || ''
-
-          if (lines.length) {
-            setOutputLines((prev) => {
-              const next = [...prev]
-              for (const line of lines) {
-                if (!line) continue
-                next.push(kind === 'stderr' ? `[err] ${line}` : line)
-              }
-              return next.slice(-MAX_OUTPUT_LINES)
-            })
-          }
-        }
-
-        child.stdout.on('data', (buf) => flushOutput('stdout', buf))
-        child.stderr.on('data', (buf) => flushOutput('stderr', buf))
-
-        child.on('error', (err) => {
-          setStatus('error')
-          setOutputLines((prev) => [...prev.slice(-MAX_OUTPUT_LINES + 1), `[launcher-error] ${err.message}`])
-        })
-
-        child.on('close', (code) => {
-          const lastOut = bufferRef.current.stdout
-          const lastErr = bufferRef.current.stderr
-
-          setOutputLines((prev) => {
-            const next = [...prev]
-            if (lastOut) pushChunk(next, lastOut)
-            if (lastErr) pushChunk(next, lastErr, 'err')
-            next.push(`[system] telegram process exited${typeof code === 'number' ? ` with code ${code}` : ''}`)
-            return next.slice(-MAX_OUTPUT_LINES)
-          })
-
-          setExitCode(typeof code === 'number' ? code : null)
-          setStatus(code === 0 ? 'exited' : 'error')
-          processRef.current = null
-          bufferRef.current = { stdout: '', stderr: '' }
-        })
-
-        setOutputLines((prev) => [...prev.slice(-MAX_OUTPUT_LINES + 1), `[system] spawned: ${botProcess.command} ${botProcess.args.join(' ')}`])
-      }
-
-      run()
-
-      return () => {
-        const proc = processRef.current
-        if (proc && !proc.killed) {
-          try {
-            proc.kill('SIGTERM')
-          } catch {
-            // no-op: process already gone
-          }
-        }
-      }
-    }, [])
-
-    useInput(
-      (input: string, key: any) => {
-        if (input === 'q' || (key.ctrl && input === 'c')) {
-          const proc = processRef.current
-          if (proc && !proc.killed) {
-            try {
-              proc.kill('SIGTERM')
-            } catch {
-              // no-op
-            }
-          }
-          exit()
-        }
-      },
-      { isActive: !!isRawModeSupported },
-    )
-
-    const statusColor = status === 'running' ? 'green' : status === 'exited' ? 'cyan' : status === 'error' ? 'red' : 'yellow'
-    const statusLabel = status === 'running' ? 'LIVE' : status === 'exited' ? `EXIT ${exitCode ?? 0}` : status === 'error' ? `ERR ${exitCode ?? '?'}` : 'BOOT'
-
-    const visibleOutputLines = outputLines.slice(-Math.max(14, (stdout.rows || 32) - 10))
-    const artLines = frameLines(currentFrame, leftWidth - 4)
-
-    return h(
-      Box,
-      { flexDirection: 'column', width: cols, paddingX: 1 },
-      h(
-        Box,
-        { justifyContent: 'space-between', marginBottom: 1 },
-        h(Text, { bold: true, color: '#61dafb' }, 'LUCA TELEGRAM // ART CONSOLE'),
-        h(Text, { color: statusColor }, `[${statusLabel}] uptime ${uptime}`),
-      ),
-      h(
-        Box,
-        { flexDirection: 'row' },
-        h(
-          Box,
-          {
-            width: leftWidth,
-            flexDirection: 'column',
-            borderStyle: 'round',
-            borderColor: '#e879f9',
-            paddingX: 1,
-            minHeight: Math.max(16, (stdout.rows || 30) - 6),
-          },
-          h(Text, { color: '#f472b6', bold: true }, `${animation.name}  (${animation.id})`),
-          h(Text, { dimColor: true }, 'bot avatar loop // modular animation script'),
-          h(Text, { dimColor: true }, '-'.repeat(Math.max(10, leftWidth - 4))),
-          ...artLines.map((line, idx) => h(Text, { key: `frame-${idx}`, color: '#fbcfe8' }, line)),
-        ),
-        h(Box, { width: 1 }, h(Text, { dimColor: true }, '|')),
-        h(
-          Box,
-          {
-            width: rightWidth,
-            flexDirection: 'column',
-            borderStyle: 'round',
-            borderColor: '#22d3ee',
-            paddingX: 1,
-            minHeight: Math.max(16, (stdout.rows || 30) - 6),
-          },
-          h(Text, { color: '#67e8f9', bold: true }, 'Telegram Bot Stream'),
-          h(Text, { dimColor: true, wrap: 'truncate' }, `source: ${botProcess.source}`),
-          h(Text, { dimColor: true }, '-'.repeat(Math.max(10, rightWidth - 4))),
-          ...visibleOutputLines.map((line, idx) =>
-            h(
-              Text,
-              {
-                key: `line-${idx}`,
-                wrap: 'truncate-middle',
-                color: line.startsWith('[err]') || line.startsWith('[launcher-error]') ? '#f87171' : undefined,
-              },
-              line,
-            ),
-          ),
-        ),
-      ),
-      h(Text, null, ''),
-      h(Text, { dimColor: true }, 'q: quit  ctrl+c: quit  env: LUCA_TELEGRAM_SCRIPT | LUCA_TELEGRAM_COMMAND | LUCA_BOT_ANIMATION'),
-      !isRawModeSupported
-        ? h(Text, { dimColor: true }, 'note: raw stdin unavailable; keyboard shortcuts disabled in this terminal')
-        : null,
-    )
-  }
-
-  await ink.render(h(App))
-  await ink.waitUntilExit()
-}
-
-await main()

package/scripts/examples/using-openai-codex.ts

@@ -1,23 +0,0 @@
-import container from '@soederpop/luca/agi'
-
-const codex = container.feature('openaiCodex')
-
-// Stream deltas as they come in
-codex.on('session:delta', ({ text }: any) => process.stdout.write(text))
-codex.on('session:exec', ({ exec }: any) => console.log(`\n[exec] ${exec.command?.join(' ')}`))
-codex.on('session:patch', ({ patch }: any) => console.log(`\n[patch] ${patch.path}`))
-
-async function main() {
-	const session = await codex.run('Explain the purpose of this project in a few sentences.', {
-		fullAuto: true,
-	})
-
-	console.log('\n---')
-	console.log('Status:', session.status)
-	console.log('Result:', session.result)
-	console.log('Turns:', session.turns)
-	console.log('Patches:', session.patches.length)
-	console.log('Execs:', session.executions.length)
-}
-
-main()

package/scripts/examples/vm-loading-esm-modules.ts

@@ -1,16 +0,0 @@
-import container from '@soederpop/luca/agi'
-
-async function main() {
-	const vm = container.feature('vm')
-	const skillsFile = container.paths.resolve('experts/luca-core-framework/skills.ts')
-	const skills = await container.fs.readFile(skillsFile)
-	const transformedSkills = await container.feature('esbuild').transform(skills.toString(), { format: 'cjs' })
-
-	const mod = { exports: {} as Record<string, any> }
-	await vm.run(transformedSkills.code, { container, module: mod, exports: mod.exports })
-
-	console.log('Loaded skills:', Object.keys(mod.exports))
-	console.log(mod.exports)
-}
-
-main()