luca 3.0.0 → 3.0.2

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

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

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

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

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

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

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