@soederpop/luca 0.1.2 → 0.1.3

package/src/web/features/helpers.ts

@@ -136,7 +136,7 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
         return {}
       }
 
-      const manifest: Manifest = await response.json()
+      const manifest = await response.json() as Manifest
       this._manifest = manifest
       this.state.set('manifestLoaded', true)
       this.emit('manifestLoaded' as any, manifest)

package/src/web/features/network.ts

@@ -1,3 +1,4 @@
+/// <reference lib="dom" />
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import { Feature } from "../feature.js";

package/test/conversation.test.ts

@@ -0,0 +1,220 @@
+import { describe, it, expect, beforeEach } from 'bun:test'
+import { AGIContainer } from '../src/agi/container.server'
+import type { Conversation } from '../src/agi/features/conversation'
+
+function makeConversation(opts: Record<string, any> = {}): Conversation {
+	const container = new AGIContainer()
+	return container.feature('conversation', { model: 'gpt-5', ...opts }) as Conversation
+}
+
+describe('Conversation', () => {
+	describe('state', () => {
+		it('initializes with empty messages when no history provided', () => {
+			const conv = makeConversation()
+			expect(conv.messages).toEqual([])
+		})
+
+		it('seeds message history from options', () => {
+			const history = [{ role: 'system', content: 'You are helpful.' }]
+			const conv = makeConversation({ history })
+			expect(conv.messages).toHaveLength(1)
+			expect(conv.messages[0]).toEqual(history[0])
+		})
+
+		it('uses provided model', () => {
+			const conv = makeConversation({ model: 'gpt-4.1' })
+			expect(conv.model).toBe('gpt-4.1')
+		})
+
+		it('isStreaming is false initially', () => {
+			const conv = makeConversation()
+			expect(conv.isStreaming).toBe(false)
+		})
+	})
+
+	describe('pushMessage', () => {
+		it('appends to messages', () => {
+			const conv = makeConversation()
+			conv.pushMessage({ role: 'user', content: 'hello' })
+			expect(conv.messages).toHaveLength(1)
+			expect(conv.messages[0]!.role).toBe('user')
+		})
+
+		it('does not mutate prior messages array', () => {
+			const conv = makeConversation()
+			const before = conv.messages
+			conv.pushMessage({ role: 'user', content: 'hi' })
+			expect(conv.messages).not.toBe(before)
+		})
+	})
+
+	describe('tools', () => {
+		it('starts with no tools', () => {
+			const conv = makeConversation()
+			expect(conv.availableTools).toHaveLength(0)
+		})
+
+		it('addTool registers a tool', () => {
+			const conv = makeConversation()
+			conv.addTool('greet', {
+				description: 'Says hello',
+				parameters: { type: 'object', properties: {} },
+				handler: async () => 'hello',
+			})
+			expect(conv.availableTools).toContain('greet')
+		})
+
+		it('removeTool deregisters a tool', () => {
+			const conv = makeConversation()
+			conv.addTool('greet', {
+				description: 'Says hello',
+				parameters: { type: 'object', properties: {} },
+				handler: async () => 'hello',
+			})
+			conv.removeTool('greet')
+			expect(conv.availableTools).not.toContain('greet')
+		})
+
+		it('updateTools merges without replacing unrelated tools', () => {
+			const conv = makeConversation()
+			conv.addTool('a', { description: 'A', parameters: { type: 'object', properties: {} }, handler: async () => 'a' })
+			conv.updateTools({ b: { description: 'B', parameters: { type: 'object', properties: {} }, handler: async () => 'b' } })
+			expect(conv.availableTools).toContain('a')
+			expect(conv.availableTools).toContain('b')
+		})
+
+		it('construction-time tools are available immediately', () => {
+			const conv = makeConversation({
+				tools: {
+					ping: { description: 'Ping', parameters: { type: 'object', properties: {} }, handler: async () => 'pong' }
+				}
+			})
+			expect(conv.availableTools).toContain('ping')
+		})
+	})
+
+	describe('estimateTokens', () => {
+		it('returns a near-zero baseline for empty messages', () => {
+			const conv = makeConversation()
+			expect(conv.estimateTokens()).toBeLessThan(10)
+		})
+
+		it('returns a positive number when messages exist', () => {
+			const conv = makeConversation({
+				history: [{ role: 'user', content: 'What is the capital of France?' }]
+			})
+			expect(conv.estimateTokens()).toBeGreaterThan(0)
+		})
+
+		it('increases as more messages are added', () => {
+			const conv = makeConversation()
+			conv.pushMessage({ role: 'user', content: 'Hello' })
+			const first = conv.estimateTokens()
+			conv.pushMessage({ role: 'assistant', content: 'Hi there, how can I help you today?' })
+			const second = conv.estimateTokens()
+			expect(second).toBeGreaterThan(first)
+		})
+	})
+
+	describe('stub()', () => {
+		it('exact string match returns the stub response', async () => {
+			const conv = makeConversation()
+			conv.stub('ping', 'pong')
+			const result = await conv.ask('ping')
+			expect(result).toBe('pong')
+		})
+
+		it('substring match triggers the stub', async () => {
+			const conv = makeConversation()
+			conv.stub('weather', 'Sunny and 72°F.')
+			const result = await conv.ask('what is the weather today?')
+			expect(result).toBe('Sunny and 72°F.')
+		})
+
+		it('regex match triggers the stub', async () => {
+			const conv = makeConversation()
+			conv.stub(/hello/i, 'Hey there!')
+			const result = await conv.ask('HELLO')
+			expect(result).toBe('Hey there!')
+		})
+
+		it('function response is called on each match', async () => {
+			const conv = makeConversation()
+			let callCount = 0
+			conv.stub('count', () => `call ${++callCount}`)
+			expect(await conv.ask('count')).toBe('call 1')
+			expect(await conv.ask('count')).toBe('call 2')
+		})
+
+		it('first matching stub wins', async () => {
+			const conv = makeConversation()
+			conv.stub('hello', 'first')
+			conv.stub('hello', 'second')
+			expect(await conv.ask('hello')).toBe('first')
+		})
+
+		it('appends user and assistant messages to history', async () => {
+			const conv = makeConversation()
+			conv.stub('hi', 'hello back')
+			await conv.ask('hi')
+			expect(conv.messages).toHaveLength(2)
+			expect(conv.messages[0]).toMatchObject({ role: 'user', content: 'hi' })
+			expect(conv.messages[1]).toMatchObject({ role: 'assistant', content: 'hello back' })
+		})
+
+		it('isStreaming is false after the call resolves', async () => {
+			const conv = makeConversation()
+			conv.stub('test', 'response')
+			await conv.ask('test')
+			expect(conv.isStreaming).toBe(false)
+		})
+
+		it('emits chunk events for each word', async () => {
+			const conv = makeConversation()
+			conv.stub('go', 'one two three')
+			const chunks: string[] = []
+			conv.on('chunk', (delta: string) => chunks.push(delta))
+			await conv.ask('go')
+			expect(chunks.join('')).toBe('one two three')
+		})
+
+		it('emits preview events with accumulating text', async () => {
+			const conv = makeConversation()
+			conv.stub('go', 'alpha beta')
+			const previews: string[] = []
+			conv.on('preview', (text: string) => previews.push(text))
+			await conv.ask('go')
+			expect(previews.at(-1)).toBe('alpha beta')
+			// Each preview should be longer than or equal to the previous
+			for (let i = 1; i < previews.length; i++) {
+				expect(previews[i]!.length).toBeGreaterThanOrEqual(previews[i - 1]!.length)
+			}
+		})
+
+		it('emits turnStart and turnEnd events', async () => {
+			const conv = makeConversation()
+			conv.stub('x', 'y')
+			const events: string[] = []
+			conv.on('turnStart', () => events.push('turnStart'))
+			conv.on('turnEnd', () => events.push('turnEnd'))
+			await conv.ask('x')
+			expect(events).toEqual(['turnStart', 'turnEnd'])
+		})
+
+		it('emits response event with the full text', async () => {
+			const conv = makeConversation()
+			conv.stub('question', 'the answer')
+			let emitted = ''
+			conv.on('response', (text: string) => { emitted = text })
+			await conv.ask('question')
+			expect(emitted).toBe('the answer')
+		})
+
+		it('stub is chainable', () => {
+			const conv = makeConversation()
+			const result = conv.stub('a', 'A').stub('b', 'B')
+			expect(result).toBe(conv)
+			expect(conv.availableTools).toHaveLength(0) // stubs don't affect tools
+		})
+	})
+})

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()