luca 1.1.2 → 3.0.0

package/test-integration/helpers.ts

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

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

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

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

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

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

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

@@ -0,0 +1,58 @@
+{
+  "compilerOptions": {
+    // Environment setup & latest features
+    "lib": ["ESNext", "dom", "dom.iterable"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Path mapping for absolute imports
+    "baseUrl": ".",
+    "paths": {
+      "@/experts/*": ["identities/*"],
+      "@/*": ["src/*"],
+      "@/web/*": ["src/web/*"],
+      "@/node/*": ["src/node/*"],
+      "@soederpop/luca": ["src/node.ts"],
+      "@soederpop/luca/node": ["src/node.ts"],
+      "@soederpop/luca/node/*": ["src/node/*"],
+      "@soederpop/luca/agi": ["src/agi/index.ts"],
+      "@soederpop/luca/agi/*": ["src/agi/*"],
+      "@soederpop/luca/web": ["src/browser.ts"],
+      "@soederpop/luca/web/*": ["src/web/*"],
+      "@soederpop/luca/schemas": ["src/schemas/base.ts"],
+      "@soederpop/luca/schemas/*": ["src/schemas/*"],
+      "@soederpop/luca/container": ["src/container.ts"],
+      "@soederpop/luca/client": ["src/client.ts"],
+      "@soederpop/luca/feature": ["src/feature.ts"]
+    },
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  },
+  "include": ["*.ts", "src/**/*.ts", "src/**/*.tsx", "index.ts", "scripts/**/*.ts", "assistants/**/*.ts"],
+  "exclude": [
+    "playground/**",
+    "docs/**",
+    "output/**",
+    "dist/**",
+    "../contentbase/**"
+  ]
+}

package/uv.lock

@@ -0,0 +1,8 @@
+version = 1
+revision = 1
+requires-python = ">=3.11"
+
+[[package]]
+name = "luca2"
+version = "0.1.0"
+source = { virtual = "." }

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2022 Emil Zaripov
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/cli/index.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};