@soederpop/luca 0.0.2

package/test-integration/elevenlabs.test.ts

@@ -0,0 +1,55 @@
+import {
+  requireEnv,
+  describeWithRequirements,
+  createAGIContainer,
+  API_TIMEOUT,
+} from './helpers'
+
+const elevenLabsKey = requireEnv('ELEVENLABS_API_KEY')
+
+describeWithRequirements('ElevenLabs Integration', [elevenLabsKey], () => {
+  let container: any
+  let el: any
+
+  beforeAll(async () => {
+    container = createAGIContainer()
+    el = container.client('elevenlabs', {
+      apiKey: elevenLabsKey.value,
+    })
+    await el.connect()
+  })
+
+  it(
+    'listVoices returns available voices',
+    async () => {
+      const voices = await el.listVoices()
+      expect(Array.isArray(voices)).toBe(true)
+      expect(voices.length).toBeGreaterThan(0)
+      expect(voices[0]).toHaveProperty('voice_id')
+      expect(voices[0]).toHaveProperty('name')
+    },
+    API_TIMEOUT
+  )
+
+  it(
+    'listModels returns available models',
+    async () => {
+      const models = await el.listModels()
+      expect(Array.isArray(models)).toBe(true)
+      expect(models.length).toBeGreaterThan(0)
+    },
+    API_TIMEOUT
+  )
+
+  it(
+    'synthesize produces audio buffer',
+    async () => {
+      const audio = await el.synthesize('Hello, integration test.', {
+        voiceId: '21m00Tcm4TlvDq8ikWAM', // Rachel
+      })
+      expect(audio).toBeDefined()
+      expect(audio.length).toBeGreaterThan(0)
+    },
+    API_TIMEOUT
+  )
+})

package/test-integration/google-services.test.ts

@@ -0,0 +1,80 @@
+import {
+  requireEnv,
+  describeWithRequirements,
+  createAGIContainer,
+  API_TIMEOUT,
+} from './helpers'
+
+const serviceAccountKey = requireEnv('GOOGLE_SERVICE_ACCOUNT_KEY')
+
+describeWithRequirements('Google Services Integration', [serviceAccountKey], () => {
+  let container: any
+
+  beforeAll(async () => {
+    container = createAGIContainer()
+    const auth = container.feature('googleAuth', {
+      scopes: [
+        'https://www.googleapis.com/auth/spreadsheets.readonly',
+        'https://www.googleapis.com/auth/calendar.readonly',
+      ],
+    })
+    await auth.authenticateServiceAccount()
+  })
+
+  describe('Google Sheets', () => {
+    it(
+      'getSpreadsheet returns metadata when given a valid spreadsheet ID',
+      async () => {
+        const sheets = container.feature('googleSheets')
+        // This test requires GOOGLE_TEST_SPREADSHEET_ID to be set
+        const spreadsheetId = process.env.GOOGLE_TEST_SPREADSHEET_ID
+        if (!spreadsheetId) {
+          console.log('GOOGLE_TEST_SPREADSHEET_ID not set, skipping sheets data test')
+          return
+        }
+        const meta = await sheets.getSpreadsheet(spreadsheetId)
+        expect(meta).toBeDefined()
+        expect(meta.spreadsheetId).toBe(spreadsheetId)
+      },
+      API_TIMEOUT
+    )
+
+    it(
+      'listSheets returns sheet names',
+      async () => {
+        const sheets = container.feature('googleSheets')
+        const spreadsheetId = process.env.GOOGLE_TEST_SPREADSHEET_ID
+        if (!spreadsheetId) {
+          console.log('GOOGLE_TEST_SPREADSHEET_ID not set, skipping')
+          return
+        }
+        const sheetList = await sheets.listSheets(spreadsheetId)
+        expect(Array.isArray(sheetList)).toBe(true)
+        expect(sheetList.length).toBeGreaterThan(0)
+      },
+      API_TIMEOUT
+    )
+  })
+
+  describe('Google Calendar', () => {
+    it(
+      'listCalendars returns at least one calendar',
+      async () => {
+        const calendar = container.feature('googleCalendar')
+        const calendars = await calendar.listCalendars()
+        expect(Array.isArray(calendars)).toBe(true)
+      },
+      API_TIMEOUT
+    )
+
+    it(
+      'getToday returns events array',
+      async () => {
+        const calendar = container.feature('googleCalendar')
+        const events = await calendar.getToday()
+        expect(Array.isArray(events)).toBe(true)
+      },
+      API_TIMEOUT
+    )
+  })
+})

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/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/skills-library.test.ts

@@ -0,0 +1,157 @@
+import { createAGIContainer } from './helpers'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from 'fs'
+import { join } from 'path'
+import { tmpdir } from 'os'
+
+describe('Skills Library Integration', () => {
+  let container: any
+  let tempDir: string
+  let skillsDir: string
+
+  beforeAll(async () => {
+    tempDir = realpathSync(mkdtempSync(join(tmpdir(), 'luca-skills-test-')))
+    skillsDir = join(tempDir, '.claude', 'skills')
+
+    // Create a test skill
+    const testSkillDir = join(skillsDir, 'code-review')
+    mkdirSync(testSkillDir, { recursive: true })
+    writeFileSync(
+      join(testSkillDir, 'SKILL.md'),
+      `---
+name: code-review
+description: Reviews code for common issues and suggests improvements
+version: 1.0.0
+tags:
+  - code
+  - review
+---
+
+## Instructions
+
+Review the provided code for:
+1. Common bugs and anti-patterns
+2. Performance issues
+3. Security vulnerabilities
+`
+    )
+
+    // Create another test skill
+    const debugSkillDir = join(skillsDir, 'debug-helper')
+    mkdirSync(debugSkillDir, { recursive: true })
+    writeFileSync(
+      join(debugSkillDir, 'SKILL.md'),
+      `---
+name: debug-helper
+description: Helps debug runtime errors and exceptions
+version: 1.0.0
+tags:
+  - debug
+  - errors
+---
+
+## Instructions
+
+Help the user debug their issue by asking clarifying questions.
+`
+    )
+
+    container = createAGIContainer({ cwd: tempDir })
+  })
+
+  afterAll(() => {
+    rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  it('loads skills from project directory', async () => {
+    const skills = container.feature('skillsLibrary', {
+      projectSkillsPath: join(tempDir, '.claude', 'skills'),
+    })
+    await skills.load()
+
+    const list = skills.list()
+    expect(list.length).toBeGreaterThanOrEqual(2)
+  })
+
+  it('finds a skill by name', async () => {
+    const skills = container.feature('skillsLibrary', {
+      projectSkillsPath: join(tempDir, '.claude', 'skills'),
+    })
+    await skills.load()
+
+    const entry = skills.find('code-review')
+    expect(entry).toBeDefined()
+    expect(entry!.name).toBe('code-review')
+    expect(entry!.description).toContain('Reviews code')
+  })
+
+  it('searches skills by keyword', async () => {
+    const skills = container.feature('skillsLibrary', {
+      projectSkillsPath: join(tempDir, '.claude', 'skills'),
+    })
+    await skills.load()
+
+    const results = skills.search('debug')
+    expect(results.length).toBeGreaterThanOrEqual(1)
+    expect(results[0].name).toBe('debug-helper')
+  })
+
+  it('creates a new skill', async () => {
+    const skills = container.feature('skillsLibrary', {
+      projectSkillsPath: join(tempDir, '.claude', 'skills'),
+    })
+    await skills.load()
+
+    const entry = await skills.create(
+      {
+        name: 'test-new-skill',
+        description: 'A skill created during testing',
+        body: '## Instructions\n\nDo test things.',
+        meta: { tags: ['test'], version: '0.1.0' },
+      },
+      'project'
+    )
+
+    expect(entry).toBeDefined()
+    expect(entry.name).toBe('test-new-skill')
+
+    // Verify it's findable
+    const found = skills.find('test-new-skill')
+    expect(found).toBeDefined()
+  })
+
+  it('removes a skill', async () => {
+    const skills = container.feature('skillsLibrary', {
+      projectSkillsPath: join(tempDir, '.claude', 'skills'),
+    })
+    await skills.load()
+
+    // Create one to remove
+    await skills.create(
+      {
+        name: 'to-remove',
+        description: 'Will be removed',
+        body: '## Instructions\n\nRemove me.',
+        meta: {},
+      },
+      'project'
+    )
+
+    const removed = await skills.remove('to-remove')
+    expect(removed).toBe(true)
+
+    const found = skills.find('to-remove')
+    expect(found).toBeUndefined()
+  })
+
+  it('generates system prompt block', async () => {
+    const skills = container.feature('skillsLibrary', {
+      projectSkillsPath: join(tempDir, '.claude', 'skills'),
+    })
+    await skills.load()
+
+    const block = skills.toSystemPromptBlock()
+    expect(typeof block).toBe('string')
+    expect(block).toContain('code-review')
+    expect(block).toContain('debug-helper')
+  })
+})

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