luca 2.0.0 → 3.0.0

package/test-integration/assistants-manager.test.ts

@@ -0,0 +1,113 @@
+import { createAGIContainer } from './helpers'
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, realpathSync } from 'fs'
+import { join } from 'path'
+import { tmpdir } from 'os'
+
+describe('Assistants Manager Integration', () => {
+  let container: any
+  let tempDir: string
+
+  beforeAll(() => {
+    tempDir = realpathSync(mkdtempSync(join(tmpdir(), 'luca-manager-test-')))
+    const assistantsDir = join(tempDir, 'assistants')
+
+    // Create assistant-a with CORE.md and tools.ts
+    const assistantADir = join(assistantsDir, 'assistant-a')
+    mkdirSync(assistantADir, { recursive: true })
+    writeFileSync(
+      join(assistantADir, 'CORE.md'),
+      'You are Assistant A. You help with task A.'
+    )
+    writeFileSync(
+      join(assistantADir, 'tools.ts'),
+      `export async function greet(args: { name: string }) { return 'Hello ' + args.name }`
+    )
+
+    // Create assistant-b with only CORE.md
+    const assistantBDir = join(assistantsDir, 'assistant-b')
+    mkdirSync(assistantBDir, { recursive: true })
+    writeFileSync(
+      join(assistantBDir, 'CORE.md'),
+      'You are Assistant B. You specialize in task B.'
+    )
+
+    // Create assistant-c with CORE.md and hooks.ts
+    const assistantCDir = join(assistantsDir, 'assistant-c')
+    mkdirSync(assistantCDir, { recursive: true })
+    writeFileSync(
+      join(assistantCDir, 'CORE.md'),
+      'You are Assistant C with hooks.'
+    )
+    writeFileSync(
+      join(assistantCDir, 'hooks.ts'),
+      `export function onStarted() { console.log('started') }`
+    )
+
+    container = createAGIContainer({ cwd: tempDir })
+  })
+
+  afterAll(() => {
+    rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  it('discovers assistants from directory', () => {
+    const manager = container.feature('assistantsManager')
+    await manager.discover()
+
+    const list = manager.list()
+    expect(list.length).toBe(3)
+  })
+
+  it('returns correct entry metadata', () => {
+    const manager = container.feature('assistantsManager')
+    await manager.discover()
+
+    const entryA = manager.get('assistant-a')
+    expect(entryA).toBeDefined()
+    expect(entryA!.name).toBe('assistant-a')
+    expect(entryA!.hasCorePrompt).toBe(true)
+    expect(entryA!.hasTools).toBe(true)
+    expect(entryA!.hasHooks).toBe(false)
+
+    const entryB = manager.get('assistant-b')
+    expect(entryB).toBeDefined()
+    expect(entryB!.hasCorePrompt).toBe(true)
+    expect(entryB!.hasTools).toBe(false)
+
+    const entryC = manager.get('assistant-c')
+    expect(entryC).toBeDefined()
+    expect(entryC!.hasHooks).toBe(true)
+  })
+
+  it('creates an assistant instance', () => {
+    const manager = container.feature('assistantsManager')
+    await manager.discover()
+
+    const assistant = manager.create('assistant-a', {
+      model: 'gpt-4o-mini',
+      historyMode: 'lifecycle',
+    })
+
+    expect(assistant).toBeDefined()
+    expect(assistant.systemPrompt).toContain('Assistant A')
+  })
+
+  it('generates a summary listing', () => {
+    const manager = container.feature('assistantsManager')
+    await manager.discover()
+
+    const summary = manager.toSummary()
+    expect(typeof summary).toBe('string')
+    expect(summary).toContain('assistant-a')
+    expect(summary).toContain('assistant-b')
+    expect(summary).toContain('assistant-c')
+  })
+
+  it('get returns undefined for non-existent assistant', () => {
+    const manager = container.feature('assistantsManager')
+    await manager.discover()
+
+    const entry = manager.get('non-existent')
+    expect(entry).toBeUndefined()
+  })
+})

package/test-integration/claude-code.test.ts

@@ -0,0 +1,98 @@
+import {
+  requireEnv,
+  requireBinary,
+  describeWithRequirements,
+  createAGIContainer,
+  CLI_TIMEOUT,
+} from './helpers'
+import type { AGIContainer } from '../src/agi/container.server'
+
+const anthropicKey = requireEnv('ANTHROPIC_API_KEY')
+const claudeBin = requireBinary('claude')
+
+describeWithRequirements(
+  'Claude Code Integration',
+  [anthropicKey, claudeBin],
+  () => {
+    let container: AGIContainer
+
+    beforeAll(() => {
+      container = createAGIContainer()
+    })
+
+    it(
+      'checkAvailability confirms claude is installed',
+      async () => {
+        const cc = container.feature('claudeCode')
+        const available = await cc.checkAvailability()
+        expect(available).toBe(true)
+      },
+      CLI_TIMEOUT
+    )
+
+    it(
+      'run() with a simple prompt returns a session with result',
+      async () => {
+        const cc = container.feature('claudeCode', {
+          permissionMode: 'plan',
+          model: 'claude-haiku-4-5-20251001',
+        })
+
+        const session = await cc.run(
+          'Reply with exactly: INTEGRATION_TEST_OK',
+          {
+            permissionMode: 'plan',
+            maxBudgetUsd: 0.05,
+          }
+        )
+
+        expect(session).toBeDefined()
+        expect(session.status).toBe('completed')
+        expect(typeof session.result).toBe('string')
+        expect(session.result!.length).toBeGreaterThan(0)
+      },
+      CLI_TIMEOUT
+    )
+
+    it(
+      'session events stream during execution',
+      async () => {
+        const cc = container.feature('claudeCode', {
+          permissionMode: 'plan',
+          model: 'claude-haiku-4-5-20251001',
+        })
+
+        const events: string[] = []
+        cc.on('session:start', () => events.push('start'))
+        cc.on('session:result', () => events.push('result'))
+
+        await cc.run('Say hello', {
+          permissionMode: 'plan',
+          maxBudgetUsd: 0.05,
+        })
+
+        expect(events).toContain('start')
+        expect(events).toContain('result')
+      },
+      CLI_TIMEOUT
+    )
+
+    it(
+      'session messages are populated',
+      async () => {
+        const cc = container.feature('claudeCode', {
+          permissionMode: 'plan',
+          model: 'claude-haiku-4-5-20251001',
+        })
+
+        const session = await cc.run('What is 2+2? Reply with just the number.', {
+          permissionMode: 'plan',
+          maxBudgetUsd: 0.05,
+        })
+
+        expect(session.messages.length).toBeGreaterThanOrEqual(0)
+      },
+      CLI_TIMEOUT
+    )
+  }
+)

package/test-integration/conversation-history.test.ts

@@ -0,0 +1,205 @@
+import { createAGIContainer } from './helpers'
+import type { AGIContainer } from '../src/agi/container.server'
+import { mkdtempSync, rmSync, realpathSync } from 'fs'
+import { join } from 'path'
+import { tmpdir } from 'os'
+
+describe('Conversation History Integration', () => {
+  let container: AGIContainer
+  let tempDir: string
+
+  beforeAll(() => {
+    tempDir = realpathSync(mkdtempSync(join(tmpdir(), 'luca-history-test-')))
+    container = createAGIContainer({ cwd: tempDir })
+  })
+
+  afterAll(() => {
+    rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  it('saves a conversation and loads it back', async () => {
+    const history = container.feature('conversationHistory', {
+      cachePath: join(tempDir, '.conversations'),
+    })
+
+    const record = await history.create({
+      title: 'Test Chat',
+      model: 'gpt-4o-mini',
+      messages: [
+        { role: 'system', content: 'You are helpful.' },
+        { role: 'user', content: 'Hello' },
+        { role: 'assistant', content: 'Hi there!' },
+      ],
+      tags: ['test', 'integration'],
+      thread: 'test-thread-1',
+    })
+
+    expect(record.id).toBeDefined()
+    expect(record.title).toBe('Test Chat')
+
+    const loaded = await history.load(record.id)
+    expect(loaded).not.toBeNull()
+    expect(loaded!.title).toBe('Test Chat')
+    expect(loaded!.messages).toHaveLength(3)
+    expect(loaded!.messages[2].content).toBe('Hi there!')
+    expect(loaded!.tags).toContain('test')
+    expect(loaded!.tags).toContain('integration')
+  })
+
+  it('lists conversations with filtering', async () => {
+    const history = container.feature('conversationHistory', {
+      cachePath: join(tempDir, '.conversations-list'),
+    })
+
+    await history.create({
+      title: 'Chat A',
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'A' }],
+      tags: ['alpha'],
+      thread: 'thread-a',
+    })
+
+    await history.create({
+      title: 'Chat B',
+      model: 'gpt-4o-mini',
+      messages: [{ role: 'user', content: 'B' }],
+      tags: ['beta'],
+      thread: 'thread-b',
+    })
+
+    await history.create({
+      title: 'Chat C',
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'C' }],
+      tags: ['alpha', 'gamma'],
+      thread: 'thread-a',
+    })
+
+    const all = await history.list()
+    expect(all.length).toBeGreaterThanOrEqual(3)
+
+    const alphaOnly = await history.list({ tag: 'alpha' })
+    expect(alphaOnly.length).toBeGreaterThanOrEqual(2)
+
+    const threadA = await history.list({ thread: 'thread-a' })
+    expect(threadA.length).toBeGreaterThanOrEqual(2)
+  })
+
+  it('appends messages to existing conversation', async () => {
+    const history = container.feature('conversationHistory', {
+      cachePath: join(tempDir, '.conversations-append'),
+    })
+
+    const record = await history.create({
+      title: 'Append Test',
+      model: 'gpt-4o-mini',
+      messages: [{ role: 'user', content: 'First message' }],
+      tags: [],
+    })
+
+    const updated = await history.append(record.id, [
+      { role: 'assistant', content: 'Response to first' },
+      { role: 'user', content: 'Second message' },
+    ])
+
+    expect(updated!.messages).toHaveLength(3)
+    expect(updated!.messages[1].content).toBe('Response to first')
+    expect(updated!.messages[2].content).toBe('Second message')
+  })
+
+  it('searches conversations by query', async () => {
+    const history = container.feature('conversationHistory', {
+      cachePath: join(tempDir, '.conversations-search'),
+    })
+
+    await history.create({
+      title: 'Debugging Python errors',
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'help' }],
+      tags: ['python', 'debug'],
+    })
+
+    await history.create({
+      title: 'TypeScript generics tutorial',
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'teach' }],
+      tags: ['typescript'],
+    })
+
+    const pythonResults = await history.search({ query: 'Python' })
+    expect(pythonResults.length).toBeGreaterThanOrEqual(1)
+    expect(pythonResults[0].title).toContain('Python')
+  })
+
+  it('tags and untags conversations', async () => {
+    const history = container.feature('conversationHistory', {
+      cachePath: join(tempDir, '.conversations-tags'),
+    })
+
+    const record = await history.create({
+      title: 'Tag Test',
+      model: 'gpt-4o-mini',
+      messages: [{ role: 'user', content: 'test' }],
+      tags: ['initial'],
+    })
+
+    await history.tag(record.id, 'important', 'reviewed')
+    let loaded = await history.load(record.id)
+    expect(loaded!.tags).toContain('initial')
+    expect(loaded!.tags).toContain('important')
+    expect(loaded!.tags).toContain('reviewed')
+
+    await history.untag(record.id, 'initial')
+    loaded = await history.load(record.id)
+    expect(loaded!.tags).not.toContain('initial')
+    expect(loaded!.tags).toContain('important')
+  })
+
+  it('deletes a conversation', async () => {
+    const history = container.feature('conversationHistory', {
+      cachePath: join(tempDir, '.conversations-delete'),
+    })
+
+    const record = await history.create({
+      title: 'To Delete',
+      model: 'gpt-4o-mini',
+      messages: [{ role: 'user', content: 'bye' }],
+      tags: [],
+    })
+
+    const deleted = await history.delete(record.id)
+    expect(deleted).toBe(true)
+
+    const loaded = await history.load(record.id)
+    expect(loaded).toBeNull()
+  })
+
+  it('thread operations: findByThread and deleteThread', async () => {
+    const history = container.feature('conversationHistory', {
+      cachePath: join(tempDir, '.conversations-threads'),
+    })
+
+    await history.create({
+      title: 'Thread Chat 1',
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'one' }],
+      tags: [],
+      thread: 'my-thread-123',
+    })
+
+    await history.create({
+      title: 'Thread Chat 2',
+      model: 'gpt-4o',
+      messages: [{ role: 'user', content: 'two' }],
+      tags: [],
+      thread: 'my-thread-123',
+    })
+
+    const found = await history.findByThread('my-thread-123')
+    expect(found).not.toBeNull()
+
+    await history.deleteThread('my-thread-123')
+    const afterDelete = await history.findByThread('my-thread-123')
+    expect(afterDelete).toBeNull()
+  })
+})

package/test-integration/conversation.test.ts

@@ -0,0 +1,137 @@
+import {
+  requireEnv,
+  describeWithRequirements,
+  createAGIContainer,
+  API_TIMEOUT,
+} from './helpers'
+import type { AGIContainer } from '../src/agi/container.server'
+
+const openaiKey = requireEnv('OPENAI_API_KEY')
+
+describeWithRequirements('Conversation Integration', [openaiKey], () => {
+  let container: AGIContainer
+
+  beforeAll(() => {
+    container = createAGIContainer()
+  })
+
+  it(
+    'ask() returns a response with content',
+    async () => {
+      const conv = container.feature('conversation', {
+        model: 'gpt-4o-mini',
+        history: [{ role: 'system', content: 'Reply with one short sentence.' }],
+      })
+
+      const reply = await conv.ask('What is 2 + 2?')
+      expect(typeof reply).toBe('string')
+      expect(reply.length).toBeGreaterThan(0)
+      expect(reply.toLowerCase()).toContain('4')
+    },
+    API_TIMEOUT
+  )
+
+  it(
+    'tool calling: defines a tool, verifies it gets called and result incorporated',
+    async () => {
+      const toolCalls: Array<{ name: string; args: any }> = []
+      const conv = container.feature('conversation', {
+        model: 'gpt-4o-mini',
+        history: [
+          {
+            role: 'system',
+            content:
+              'You have a calculator tool. Always use it when asked to compute something. Reply with just the result.',
+          },
+        ],
+        tools: {
+          calculator: {
+            handler: async (args: { expression: string }) => {
+              return String(eval(args.expression))
+            },
+            description: 'Evaluates a math expression and returns the result',
+            parameters: {
+              type: 'object',
+              properties: {
+                expression: {
+                  type: 'string',
+                  description: 'A math expression like "2 + 2"',
+                },
+              },
+              required: ['expression'],
+            },
+          },
+        },
+      })
+
+      conv.on('toolCall', (name: string, args: any) =>
+        toolCalls.push({ name, args })
+      )
+
+      const reply = await conv.ask('What is 15 * 7?')
+      expect(reply).toContain('105')
+      expect(toolCalls.length).toBeGreaterThanOrEqual(1)
+      expect(toolCalls[0].name).toBe('calculator')
+    },
+    API_TIMEOUT
+  )
+
+  it(
+    'streaming: chunk events fire during response',
+    async () => {
+      const chunks: string[] = []
+      const conv = container.feature('conversation', {
+        model: 'gpt-4o-mini',
+        history: [{ role: 'system', content: 'Reply with exactly: Hello world' }],
+      })
+
+      conv.on('chunk', (text: string) => chunks.push(text))
+
+      const reply = await conv.ask('Say hello')
+      expect(reply.length).toBeGreaterThan(0)
+      expect(chunks.length).toBeGreaterThan(0)
+    },
+    API_TIMEOUT
+  )
+
+  it(
+    'messages accumulate across turns',
+    async () => {
+      const conv = container.feature('conversation', {
+        model: 'gpt-4o-mini',
+        history: [
+          {
+            role: 'system',
+            content: 'Remember everything. Reply in one short sentence.',
+          },
+        ],
+      })
+
+      await conv.ask('My favorite color is blue.')
+      expect(conv.messages.length).toBeGreaterThanOrEqual(3) // system + user + assistant
+
+      await conv.ask('What is my favorite color?')
+      expect(conv.messages.length).toBeGreaterThanOrEqual(5)
+    },
+    API_TIMEOUT
+  )
+
+  it(
+    'turnStart and turnEnd events fire',
+    async () => {
+      const events: string[] = []
+      const conv = container.feature('conversation', {
+        model: 'gpt-4o-mini',
+        history: [{ role: 'system', content: 'Reply briefly.' }],
+      })
+
+      conv.on('turnStart', () => events.push('turnStart'))
+      conv.on('turnEnd', () => events.push('turnEnd'))
+
+      await conv.ask('Hi')
+      expect(events).toContain('turnStart')
+      expect(events).toContain('turnEnd')
+    },
+    API_TIMEOUT
+  )
+})

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