luca 3.0.0 → 3.0.2

package/test-integration/helpers.ts

@@ -1,89 +0,0 @@
-import { AGIContainer } from '../src/agi/container.server'
-import { NodeContainer } from '../src/node/container'
-import { mkdtempSync, rmSync, realpathSync } from 'fs'
-import { join } from 'path'
-import { tmpdir } from 'os'
-import { execSync } from 'child_process'
-
-/**
- * Checks that an environment variable is set.
- * Returns its value, or calls describe.skip-style logic.
- * Use at the top of describe blocks — if missing, the value will be empty string
- * and `shouldSkip()` returns the skip reason.
- */
-export function requireEnv(name: string): { value: string; skip?: string } {
-  const value = process.env[name]
-  if (!value) {
-    return { value: '', skip: `${name} not set, skipping` }
-  }
-  return { value }
-}
-
-/**
- * Checks that a binary is available on PATH.
- * Returns the path or a skip reason.
- */
-export function requireBinary(name: string): { path: string; skip?: string } {
-  try {
-    const result = execSync(`which ${name}`, { encoding: 'utf-8' }).trim()
-    return { path: result }
-  } catch {
-    return { path: '', skip: `'${name}' binary not found in PATH, skipping` }
-  }
-}
-
-/**
- * Creates a describe block that skips if any of the provided checks have skip reasons.
- */
-export function describeWithRequirements(
-  title: string,
-  checks: Array<{ skip?: string }>,
-  fn: () => void
-) {
-  const skipReason = checks.find((c) => c.skip)?.skip
-  if (skipReason) {
-    describe.skip(`${title} (${skipReason})`, fn)
-  } else {
-    describe(title, fn)
-  }
-}
-
-/**
- * Creates an AGIContainer for integration tests.
- */
-export function createAGIContainer(opts?: { cwd?: string }): any {
-  const options = opts?.cwd ? { cwd: opts.cwd } : undefined
-  return new (AGIContainer as any)(options)
-}
-
-/**
- * Creates a NodeContainer with an optional temp directory.
- * If useTempDir is true, creates a temp directory and cleans up on dispose.
- */
-export function createNodeContainer(opts?: {
-  cwd?: string
-  useTempDir?: boolean
-}): { container: NodeContainer; tempDir?: string; cleanup: () => void } {
-  if (opts?.useTempDir) {
-    const tempDir = realpathSync(mkdtempSync(join(tmpdir(), 'luca-integ-')))
-    const container = new NodeContainer({ cwd: tempDir })
-    return {
-      container,
-      tempDir,
-      cleanup: () => rmSync(tempDir, { recursive: true, force: true }),
-    }
-  }
-
-  const container = new NodeContainer({ cwd: opts?.cwd || process.cwd() })
-  return { container, cleanup: () => {} }
-}
-
-/**
- * Default timeout for API-calling tests (30 seconds).
- */
-export const API_TIMEOUT = 30_000
-
-/**
- * Extended timeout for slow operations like CLI subprocesses (60 seconds).
- */
-export const CLI_TIMEOUT = 60_000

package/test-integration/memory.test.ts

@@ -1,204 +0,0 @@
-import {
-  requireEnv,
-  describeWithRequirements,
-  createAGIContainer,
-  API_TIMEOUT,
-} from './helpers'
-import type { AGIContainer } from '../src/agi/container.server'
-import type { Memory } from '../src/agi/features/agent-memory'
-
-const openaiKey = requireEnv('OPENAI_API_KEY')
-
-describeWithRequirements('Memory Integration', [openaiKey], () => {
-  let container: AGIContainer
-  let mem: Memory
-
-  beforeAll(async () => {
-    container = createAGIContainer()
-    mem = container.feature('memory', { namespace: 'test-integration' }) as unknown as Memory
-    await mem.initDb()
-    await mem.wipeAll()
-  })
-
-  afterAll(async () => {
-    await mem.wipeAll()
-  })
-
-  describe('Feature registration', () => {
-    it('registers in the container', () => {
-      expect(container.features.available).toContain('memory')
-    })
-
-    it('has correct shortcut', () => {
-      const { Memory: MemClass } = require('../src/agi/features/agent-memory')
-      expect(MemClass.shortcut).toBe('features.memory')
-    })
-
-    it('initializes database', () => {
-      expect(mem.state.get('dbReady')).toBe(true)
-    })
-  })
-
-  describe('CRUD operations', () => {
-    it('creates and retrieves a memory', async () => {
-      const m = await mem.create('facts', 'Jonathan is a software engineer based in Austin')
-      expect(m.id).toBeGreaterThan(0)
-      expect(m.category).toBe('facts')
-      expect(m.document).toBe('Jonathan is a software engineer based in Austin')
-
-      const fetched = await mem.get('facts', m.id)
-      expect(fetched).not.toBeNull()
-      expect(fetched!.document).toBe(m.document)
-    }, API_TIMEOUT)
-
-    it('updates a memory', async () => {
-      const m = await mem.create('facts', 'Prefers dark mode')
-      const updated = await mem.update('facts', m.id, {
-        text: 'Prefers dark mode, especially Dracula theme',
-        metadata: { updated: 'true' },
-      })
-      expect(updated!.document).toBe('Prefers dark mode, especially Dracula theme')
-      expect(updated!.metadata.updated).toBe('true')
-    }, API_TIMEOUT)
-
-    it('deletes a memory', async () => {
-      const m = await mem.create('scratch', 'temporary memory')
-      expect(await mem.delete('scratch', m.id)).toBe(true)
-      expect(await mem.get('scratch', m.id)).toBeNull()
-    }, API_TIMEOUT)
-
-    it('lists categories', async () => {
-      const cats = await mem.categories()
-      expect(cats).toContain('facts')
-    })
-
-    it('counts memories', async () => {
-      const total = await mem.count()
-      expect(total).toBeGreaterThan(0)
-      const factCount = await mem.count('facts')
-      expect(factCount).toBeGreaterThan(0)
-    })
-
-    it('gets all memories with filtering', async () => {
-      await mem.create('prefs', 'Likes iterative delivery', { source: 'onboarding' })
-      await mem.create('prefs', 'Prefers concise responses')
-
-      const onboarding = await mem.getAll('prefs', { filterMetadata: { source: 'onboarding' } })
-      expect(onboarding.length).toBeGreaterThan(0)
-      expect(onboarding.every(m => m.metadata.source === 'onboarding')).toBe(true)
-    }, API_TIMEOUT)
-  })
-
-  describe('Semantic search', () => {
-    it('finds relevant memories by query', async () => {
-      const results = await mem.search('facts', 'Where does the user live?', 3)
-      expect(results.length).toBeGreaterThan(0)
-      expect(results[0].distance).toBeLessThan(1)
-    }, API_TIMEOUT)
-  })
-
-  describe('Deduplication', () => {
-    it('blocks near-duplicate memories', async () => {
-      const before = await mem.count('facts')
-      const dup = await mem.createUnique('facts', 'Jonathan is a software engineer living in Austin, TX')
-      const after = await mem.count('facts')
-      expect(dup).toBeNull()
-      expect(after).toBe(before)
-    }, API_TIMEOUT)
-  })
-
-  describe('Epochs and events', () => {
-    it('tracks epoch state', () => {
-      expect(mem.getEpoch()).toBe(1)
-    })
-
-    it('creates events and increments epoch', async () => {
-      await mem.createEvent('User started a new project')
-      await mem.incrementEpoch()
-      expect(mem.getEpoch()).toBe(2)
-
-      await mem.createEvent('User requested a test script')
-
-      const e1 = await mem.getEvents({ epoch: 1 })
-      const e2 = await mem.getEvents({ epoch: 2 })
-      expect(e1.length).toBeGreaterThan(0)
-      expect(e2.length).toBeGreaterThan(0)
-    }, API_TIMEOUT)
-  })
-
-  describe('Export and import', () => {
-    it('roundtrips through export/import', async () => {
-      const exported = await mem.exportToJson()
-      expect(exported.memories.length).toBeGreaterThan(0)
-
-      await mem.wipeAll()
-      expect(await mem.count()).toBe(0)
-
-      const imported = await mem.importFromJson(exported)
-      expect(imported).toBe(exported.memories.length)
-      expect(await mem.count()).toBe(exported.memories.length)
-    }, API_TIMEOUT * 3)
-  })
-
-  describe('Tool interface (toTools)', () => {
-    it('exposes tools via standard toTools() pattern', () => {
-      const { schemas, handlers } = mem.toTools()
-      expect(Object.keys(schemas)).toContain('remember')
-      expect(Object.keys(schemas)).toContain('recall')
-      expect(Object.keys(schemas)).toContain('forgetCategory')
-      expect(Object.keys(schemas)).toContain('listCategories')
-      expect(typeof handlers.remember).toBe('function')
-      expect(typeof handlers.recall).toBe('function')
-      expect(typeof handlers.forgetCategory).toBe('function')
-      expect(typeof handlers.listCategories).toBe('function')
-    })
-
-    it('toTools only/except filtering works', () => {
-      const { schemas: onlySchemas } = mem.toTools({ only: ['remember', 'recall'] })
-      expect(Object.keys(onlySchemas)).toEqual(['remember', 'recall'])
-
-      const { schemas: exceptSchemas } = mem.toTools({ except: ['forgetCategory'] })
-      expect(Object.keys(exceptSchemas)).not.toContain('forgetCategory')
-      expect(Object.keys(exceptSchemas)).toContain('remember')
-    })
-
-    it('remember tool stores and deduplicates', async () => {
-      const { handlers } = mem.toTools()
-      const result = await handlers.remember({ category: 'facts', text: 'Has a golden retriever named Max' })
-      expect(result.stored).toBe(true)
-
-      const dup = await handlers.remember({ category: 'facts', text: 'Has a golden retriever named Max' })
-      expect(dup.stored).toBe(false)
-    }, API_TIMEOUT)
-
-    it('recall tool searches memories', async () => {
-      const { handlers } = mem.toTools()
-      const results = await handlers.recall({ category: 'facts', query: 'pets and animals', n_results: 2 })
-      expect(results.length).toBeGreaterThan(0)
-      expect(results[0]).toHaveProperty('document')
-      expect(results[0]).toHaveProperty('distance')
-    }, API_TIMEOUT)
-
-    it('listCategories tool returns counts', async () => {
-      const { handlers } = mem.toTools()
-      const result = await handlers.listCategories()
-      expect(result.categories).toBeDefined()
-      expect(typeof result.categories.facts).toBe('number')
-    })
-  })
-
-  describe('Wipe operations', () => {
-    it('wipeCategory removes only that category', async () => {
-      const before = await mem.count()
-      const deleted = await mem.wipeCategory('scratch')
-      const after = await mem.count()
-      expect(after).toBeLessThanOrEqual(before)
-    })
-
-    it('wipeAll removes everything and resets epoch', async () => {
-      await mem.wipeAll()
-      expect(await mem.count()).toBe(0)
-      expect(mem.getEpoch()).toBe(1)
-    })
-  })
-})

package/test-integration/openai-codex.test.ts

@@ -1,93 +0,0 @@
-import {
-  requireEnv,
-  requireBinary,
-  describeWithRequirements,
-  createAGIContainer,
-  CLI_TIMEOUT,
-} from './helpers'
-import type { AGIContainer } from '../src/agi/container.server'
-
-const openaiKey = requireEnv('OPENAI_API_KEY')
-const codexBin = requireBinary('codex')
-
-describeWithRequirements(
-  'OpenAI Codex Integration',
-  [openaiKey, codexBin],
-  () => {
-    let container: AGIContainer
-
-    beforeAll(() => {
-      container = createAGIContainer()
-    })
-
-    it(
-      'checkAvailability confirms codex is installed',
-      async () => {
-        const codex = container.feature('openaiCodex')
-        const available = await codex.checkAvailability()
-        expect(available).toBe(true)
-      },
-      CLI_TIMEOUT
-    )
-
-    it(
-      'run() with a simple prompt in read-only sandbox returns a session',
-      async () => {
-        const codex = container.feature('openaiCodex', {
-          sandbox: 'read-only',
-          model: 'o4-mini',
-        })
-
-        const session = await codex.run(
-          'Reply with exactly: CODEX_TEST_OK',
-          {
-            sandbox: 'read-only',
-          }
-        )
-
-        expect(session).toBeDefined()
-        expect(session.status).toBe('completed')
-        expect(typeof session.result).toBe('string')
-      },
-      CLI_TIMEOUT
-    )
-
-    it(
-      'session events fire during execution',
-      async () => {
-        const codex = container.feature('openaiCodex', {
-          sandbox: 'read-only',
-          model: 'o4-mini',
-        })
-
-        const events: string[] = []
-        codex.on('session:start', () => events.push('start'))
-        codex.on('session:result', () => events.push('result'))
-
-        await codex.run('Say hello', { sandbox: 'read-only' })
-
-        expect(events).toContain('start')
-        expect(events).toContain('result')
-      },
-      CLI_TIMEOUT
-    )
-
-    it(
-      'session items are populated from event stream',
-      async () => {
-        const codex = container.feature('openaiCodex', {
-          sandbox: 'read-only',
-          model: 'o4-mini',
-        })
-
-        const session = await codex.run('What is 2+2? Reply with just the number.', {
-          sandbox: 'read-only',
-        })
-
-        // Items array should exist even if empty
-        expect(Array.isArray(session.items)).toBe(true)
-      },
-      CLI_TIMEOUT
-    )
-  }
-)

package/test-integration/runpod.test.ts

@@ -1,58 +0,0 @@
-import {
-  requireEnv,
-  describeWithRequirements,
-  createAGIContainer,
-  API_TIMEOUT,
-} from './helpers'
-
-const runpodKey = requireEnv('RUNPOD_API_KEY')
-
-describeWithRequirements('RunPod Integration', [runpodKey], () => {
-  let container: any
-  let runpod: any
-
-  beforeAll(() => {
-    container = createAGIContainer()
-    runpod = container.feature('runpod', {
-      apiKey: runpodKey.value,
-    })
-  })
-
-  it(
-    'lists templates (read-only)',
-    async () => {
-      const templates = await runpod.listTemplates({ includeRunpod: true })
-      expect(Array.isArray(templates)).toBe(true)
-      expect(templates.length).toBeGreaterThan(0)
-    },
-    API_TIMEOUT
-  )
-
-  it(
-    'lists secure GPU availability',
-    async () => {
-      const gpus = await runpod.listSecureGPUs()
-      expect(Array.isArray(gpus)).toBe(true)
-      expect(gpus.length).toBeGreaterThan(0)
-    },
-    API_TIMEOUT
-  )
-
-  it(
-    'lists network volumes',
-    async () => {
-      const volumes = await runpod.listVolumes()
-      expect(Array.isArray(volumes)).toBe(true)
-    },
-    API_TIMEOUT
-  )
-
-  it(
-    'lists existing pods',
-    async () => {
-      const pods = await runpod.listPods()
-      expect(Array.isArray(pods)).toBe(true)
-    },
-    API_TIMEOUT
-  )
-})

package/test-integration/server-endpoints.test.ts

@@ -1,97 +0,0 @@
-import {
-  requireEnv,
-  describeWithRequirements,
-  createAGIContainer,
-  API_TIMEOUT,
-} from './helpers'
-
-const openaiKey = requireEnv('OPENAI_API_KEY')
-
-describeWithRequirements('Server & Endpoints Integration', [openaiKey], () => {
-  let container: any
-  let server: any
-  let port: number
-
-  beforeAll(async () => {
-    container = createAGIContainer()
-
-    server = container.server('express', {
-      port: 0,
-      cors: true,
-      create: (app: any) => {
-        app.get('/health', (_req: any, res: any) => {
-          res.json({ status: 'ok' })
-        })
-        return app
-      },
-    })
-
-    await server.start()
-    port = server.port
-  }, API_TIMEOUT)
-
-  afterAll(async () => {
-    if (server?.isListening) {
-      await server.stop()
-    }
-  })
-
-  it('server starts and reports listening', () => {
-    expect(server.isListening).toBe(true)
-    expect(port).toBeGreaterThan(0)
-  })
-
-  it(
-    'health endpoint returns OK',
-    async () => {
-      const res = await fetch(`http://localhost:${port}/health`)
-      expect(res.status).toBe(200)
-      const body = await res.json()
-      expect(body.status).toBe('ok')
-    },
-    API_TIMEOUT
-  )
-
-  it(
-    'loads AGI endpoints directory',
-    async () => {
-      const agiEndpointsDir = container.paths.resolve(
-        'src',
-        'agi',
-        'endpoints'
-      )
-
-      if (container.fs.exists(agiEndpointsDir)) {
-        await server.useEndpoints(agiEndpointsDir)
-        // After loading endpoints, the /ask endpoint should be available
-        const res = await fetch(`http://localhost:${port}/ask`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            question: 'Reply with exactly: ENDPOINT_TEST_OK',
-            model: 'gpt-4o-mini',
-          }),
-        })
-        // The endpoint may stream SSE or return JSON
-        expect(res.status).toBeLessThan(500)
-      }
-    },
-    API_TIMEOUT
-  )
-
-  it(
-    'server shuts down cleanly',
-    async () => {
-      const testServer = container.server('express', {
-        port: 0,
-        cors: true,
-      })
-      await testServer.start()
-      expect(testServer.isListening).toBe(true)
-
-      await testServer.stop()
-      expect(testServer.isStopped).toBe(true)
-    },
-    API_TIMEOUT
-  )
-})

package/test-integration/telegram.test.ts

@@ -1,46 +0,0 @@
-import {
-  requireEnv,
-  describeWithRequirements,
-  createAGIContainer,
-  API_TIMEOUT,
-} from './helpers'
-
-const telegramToken = requireEnv('TELEGRAM_BOT_TOKEN')
-
-describeWithRequirements('Telegram Integration', [telegramToken], () => {
-  let container: any
-  let tg: any
-
-  beforeAll(async () => {
-    container = createAGIContainer()
-    tg = container.feature('telegram', {
-      token: telegramToken.value,
-      autoStart: false,
-      pollingTimeout: 0,
-    })
-    await tg.enable()
-  })
-
-  it(
-    'getMe returns bot info',
-    async () => {
-      const me = await tg.getMe()
-      expect(me).toBeDefined()
-      expect(me.id).toBeDefined()
-      expect(typeof me.first_name).toBe('string')
-      expect(me.is_bot).toBe(true)
-    },
-    API_TIMEOUT
-  )
-
-  it('command registration works', () => {
-    tg.command('test_integ', (ctx: any) => ctx.reply('test'))
-    // If command registration didn't throw, it's working
-    expect(true).toBe(true)
-  })
-
-  it('bot instance is accessible', () => {
-    expect(tg.bot).toBeDefined()
-    expect(tg.bot.api).toBeDefined()
-  })
-})