luca 3.0.0 → 3.0.2

package/src/agi/endpoints/conversations/[id].ts

@@ -1,45 +0,0 @@
-import { z } from 'zod'
-import type { EndpointContext } from '../../../endpoint.js'
-
-export const path = '/api/conversations/:id'
-export const description = 'Get or delete a specific conversation'
-export const tags = ['conversations']
-
-export const getSchema = z.object({
-  id: z.string().describe('Conversation ID'),
-})
-
-export async function get(parameters: z.infer<typeof getSchema>, ctx: EndpointContext) {
-  const container = ctx.container as any
-  const history = container.feature('conversationHistory')
-
-  const record = await history.load(parameters.id)
-
-  if (!record) {
-    ctx.response.status(404)
-    return { error: 'Conversation not found' }
-  }
-
-  return { conversation: record }
-}
-
-export const deleteSchema = z.object({
-  id: z.string().describe('Conversation ID'),
-})
-
-export async function del(parameters: z.infer<typeof deleteSchema>, ctx: EndpointContext) {
-  const container = ctx.container as any
-  const history = container.feature('conversationHistory')
-
-  const deleted = await history.delete(parameters.id)
-
-  if (!deleted) {
-    ctx.response.status(404)
-    return { error: 'Conversation not found' }
-  }
-
-  return { deleted: true }
-}
-
-// endpoint system uses 'delete' as the key
-export { del as delete }

package/src/agi/endpoints/conversations.ts

@@ -1,31 +0,0 @@
-import { z } from 'zod'
-import type { EndpointContext } from '../../endpoint.js'
-
-export const path = '/api/conversations'
-export const description = 'List and search saved conversations'
-export const tags = ['conversations']
-
-export const getSchema = z.object({
-  tag: z.string().optional().describe('Filter by tag'),
-  thread: z.string().optional().describe('Filter by thread'),
-  model: z.string().optional().describe('Filter by model'),
-  query: z.string().optional().describe('Text search across titles, tags, metadata'),
-  expert: z.string().optional().describe('Filter by expert name (stored in metadata)'),
-  limit: z.coerce.number().optional().describe('Max results'),
-  offset: z.coerce.number().optional().describe('Skip N results'),
-})
-
-export async function get(parameters: z.infer<typeof getSchema>, ctx: EndpointContext) {
-  const container = ctx.container as any
-  const history = container.feature('conversationHistory')
-
-  const { expert, ...searchOpts } = parameters
-
-  let results = await history.list(searchOpts)
-
-  if (expert) {
-    results = results.filter((m: any) => m.metadata?.expert === expert)
-  }
-
-  return { conversations: results }
-}

package/src/agi/endpoints/experts.ts

@@ -1,37 +0,0 @@
-import { z } from 'zod'
-import type { EndpointContext } from '../../endpoint.js'
-
-export const path = '/api/experts'
-export const description = 'List all available experts with their descriptions'
-export const tags = ['experts']
-
-export async function get(_parameters: any, ctx: EndpointContext) {
-  const container = ctx.container as any
-  const fs = container.feature('fs')
-  const fileManager = container.feature('fileManager')
-
-  if (!fileManager.isStarted) {
-    await fileManager.start()
-  }
-
-  const promptFiles = fileManager.match('experts/*/SYSTEM-PROMPT.md')
-  const experts: any[] = []
-
-  for (const relativePath of promptFiles) {
-    const name = relativePath.split('/')[1]
-    const prompt = await fs.readFileAsync(container.paths.resolve(relativePath))
-    const lines = prompt.split('\n').filter((l: string) => l.trim())
-    const title = lines[0]?.replace(/^#+\s*/, '') || name
-    const description = lines[1] || ''
-
-    experts.push({
-      name,
-      title,
-      description,
-      url: `/api/experts/${name}`,
-      askUrl: `/api/experts/${name}/ask`,
-    })
-  }
-
-  return { experts }
-}

package/test/assistant-hooks.test.ts

@@ -1,306 +0,0 @@
-import { describe, it, expect, beforeEach } from 'bun:test'
-import { AGIContainer } from '../src/agi/container.server'
-import type { Assistant } from '../src/agi/features/assistant'
-
-/**
- * Helper: create a runtime assistant with no folder, stub the conversation
- * so tests never hit the network, and inject hook functions directly.
- */
-function makeAssistant(hooks: Record<string, (...args: any[]) => any> = {}) {
-	const container = new AGIContainer()
-	const assistant = container.feature('assistant', {
-		systemPrompt: 'You are a test assistant.',
-		model: 'gpt-5',
-	}) as Assistant
-
-	// Inject hooks into state (same shape loadHooks() produces)
-	assistant.state.set('hooks', hooks)
-
-	return assistant
-}
-
-/** Start + stub so ask() never touches the network */
-async function startWithStub(assistant: Assistant, pattern: string | RegExp = /.*/, response: string = 'stubbed') {
-	await assistant.start()
-	assistant.conversation.stub(pattern, response)
-	return assistant
-}
-
-describe('Assistant triggerHook', () => {
-	it('returns undefined when no hook exists for the name', async () => {
-		const assistant = makeAssistant()
-		const result = await assistant.triggerHook('nonexistent', 'arg1')
-		expect(result).toBeUndefined()
-	})
-
-	it('calls the hook with (assistant, ...args) and awaits it', async () => {
-		const calls: any[][] = []
-		const assistant = makeAssistant({
-			myHook: async (asst: any, a: string, b: number) => {
-				calls.push([asst, a, b])
-				return 'hook-result'
-			},
-		})
-
-		const result = await assistant.triggerHook('myHook', 'hello', 42)
-		expect(result).toBe('hook-result')
-		expect(calls).toHaveLength(1)
-		expect(calls[0]![0]).toBe(assistant)
-		expect(calls[0]![1]).toBe('hello')
-		expect(calls[0]![2]).toBe(42)
-	})
-
-	it('emits hookFired before calling the hook', async () => {
-		const events: string[] = []
-		const assistant = makeAssistant({
-			myHook: async () => { events.push('hook-ran') },
-		})
-		assistant.on('hookFired', (name: string) => { events.push(`hookFired:${name}`) })
-
-		await assistant.triggerHook('myHook')
-		expect(events).toEqual(['hookFired:myHook', 'hook-ran'])
-	})
-
-	it('awaits async hooks to completion before returning', async () => {
-		let resolved = false
-		const assistant = makeAssistant({
-			slowHook: async () => {
-				await new Promise(r => setTimeout(r, 50))
-				resolved = true
-			},
-		})
-
-		await assistant.triggerHook('slowHook')
-		expect(resolved).toBe(true)
-	})
-})
-
-describe('Assistant lifecycle hooks', () => {
-	it('beforeStart runs before the assistant is started', async () => {
-		const order: string[] = []
-		const assistant = makeAssistant({
-			beforeStart: async () => { order.push('beforeStart') },
-			started: async () => { order.push('started') },
-			afterStart: async () => { order.push('afterStart') },
-		})
-
-		await assistant.start()
-		expect(order).toEqual(['beforeStart', 'started', 'afterStart'])
-	})
-
-	it('afterStart blocks start() until complete', async () => {
-		let afterStartDone = false
-		const assistant = makeAssistant({
-			afterStart: async () => {
-				await new Promise(r => setTimeout(r, 50))
-				afterStartDone = true
-			},
-		})
-
-		await assistant.start()
-		expect(afterStartDone).toBe(true)
-	})
-
-	it('formatSystemPrompt modifies the system prompt before conversation creation', async () => {
-		const assistant = makeAssistant({
-			formatSystemPrompt: async (_asst: any, prompt: string) => {
-				return prompt + '\nExtra instructions.'
-			},
-		})
-
-		await assistant.start()
-		expect(assistant.systemPrompt).toContain('Extra instructions.')
-	})
-})
-
-describe('Assistant ask hooks', () => {
-	it('beforeAsk fires on every ask() call', async () => {
-		let callCount = 0
-		const assistant = makeAssistant({
-			beforeAsk: async () => { callCount++ },
-		})
-		await startWithStub(assistant)
-
-		await assistant.ask('first')
-		await assistant.ask('second')
-		expect(callCount).toBe(2)
-	})
-
-	it('beforeAsk can rewrite the question via return value', async () => {
-		const questionsReceived: string[] = []
-		const assistant = makeAssistant({
-			beforeAsk: async (_asst: any, question: string) => {
-				return question + ' (rewritten)'
-			},
-		})
-		await assistant.start()
-
-		// Stub that captures the actual question sent to the conversation
-		assistant.conversation.on('userMessage', (content: any) => {
-			questionsReceived.push(typeof content === 'string' ? content : JSON.stringify(content))
-		})
-		assistant.conversation.stub(/.*/, 'ok')
-
-		await assistant.ask('hello')
-		expect(questionsReceived[0]).toContain('(rewritten)')
-	})
-
-	it('beforeInitialAsk fires only on the first ask()', async () => {
-		let callCount = 0
-		const assistant = makeAssistant({
-			beforeInitialAsk: async () => { callCount++ },
-		})
-		await startWithStub(assistant)
-
-		await assistant.ask('first')
-		await assistant.ask('second')
-		await assistant.ask('third')
-		expect(callCount).toBe(1)
-	})
-
-	it('answered hook fires after the response is produced', async () => {
-		let hookResponse: string | undefined
-		const assistant = makeAssistant({
-			answered: async (_asst: any, result: string) => {
-				hookResponse = result
-			},
-		})
-		await startWithStub(assistant, /.*/, 'the answer')
-
-		await assistant.ask('question')
-		expect(hookResponse).toBe('the answer')
-	})
-
-	it('answered hook is awaited before ask() returns', async () => {
-		let hookDone = false
-		const assistant = makeAssistant({
-			answered: async () => {
-				await new Promise(r => setTimeout(r, 50))
-				hookDone = true
-			},
-		})
-		await startWithStub(assistant)
-
-		await assistant.ask('question')
-		expect(hookDone).toBe(true)
-	})
-})
-
-describe('Assistant tool hooks', () => {
-	it('beforeToolCall hook fires before tool execution', async () => {
-		const hookCalls: any[] = []
-		const assistant = makeAssistant({
-			beforeToolCall: async (_asst: any, ctx: any) => {
-				hookCalls.push({ name: ctx.name, args: { ...ctx.args } })
-			},
-		})
-		await assistant.start()
-
-		// Add a simple tool and stub a response that triggers it
-		assistant.addTool('echo', {
-			description: 'Echo tool',
-			parameters: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'] },
-			handler: async (args: any) => args.text,
-		})
-
-		// Directly invoke the toolExecutor to test hooks without needing model responses
-		const handler = async (args: any) => args.text
-		await assistant.conversation.toolExecutor!('echo', { text: 'hello' }, handler)
-
-		expect(hookCalls).toHaveLength(1)
-		expect(hookCalls[0]!.name).toBe('echo')
-		expect(hookCalls[0]!.args.text).toBe('hello')
-	})
-
-	it('afterToolCall hook fires after tool execution with result', async () => {
-		const hookCalls: any[] = []
-		const assistant = makeAssistant({
-			afterToolCall: async (_asst: any, ctx: any) => {
-				hookCalls.push({ name: ctx.name, result: ctx.result })
-			},
-		})
-		await assistant.start()
-
-		const handler = async (args: any) => args.text
-		await assistant.conversation.toolExecutor!('echo', { text: 'world' }, handler)
-
-		expect(hookCalls).toHaveLength(1)
-		expect(hookCalls[0]!.name).toBe('echo')
-		expect(hookCalls[0]!.result).toBe('world')
-	})
-
-	it('beforeToolCall can modify args via ctx mutation', async () => {
-		const assistant = makeAssistant({
-			beforeToolCall: async (_asst: any, ctx: any) => {
-				ctx.args.text = 'intercepted'
-			},
-		})
-		await assistant.start()
-
-		let receivedArgs: any
-		const handler = async (args: any) => { receivedArgs = args; return 'ok' }
-		await assistant.conversation.toolExecutor!('echo', { text: 'original' }, handler)
-
-		expect(receivedArgs.text).toBe('intercepted')
-	})
-
-	it('beforeToolCall can skip execution via ctx.skip', async () => {
-		const assistant = makeAssistant({
-			beforeToolCall: async (_asst: any, ctx: any) => {
-				ctx.skip = true
-				ctx.result = 'skipped-by-hook'
-			},
-		})
-		await assistant.start()
-
-		let handlerCalled = false
-		const handler = async () => { handlerCalled = true; return 'should not run' }
-		const result = await assistant.conversation.toolExecutor!('echo', { text: 'hi' }, handler)
-
-		expect(handlerCalled).toBe(false)
-		expect(result).toBe('skipped-by-hook')
-	})
-
-	it('afterToolCall can modify the result via ctx mutation', async () => {
-		const assistant = makeAssistant({
-			afterToolCall: async (_asst: any, ctx: any) => {
-				ctx.result = 'modified-result'
-			},
-		})
-		await assistant.start()
-
-		const handler = async () => 'original-result'
-		const result = await assistant.conversation.toolExecutor!('echo', {}, handler)
-
-		expect(result).toBe('modified-result')
-	})
-})
-
-describe('Assistant forwarded event hooks', () => {
-	it('turnStart hook fires before the turnStart event on the assistant bus', async () => {
-		const order: string[] = []
-		const assistant = makeAssistant({
-			turnStart: async () => { order.push('hook') },
-		})
-		await startWithStub(assistant)
-
-		assistant.on('turnStart', () => { order.push('event') })
-
-		await assistant.ask('go')
-		expect(order[0]).toBe('hook')
-		expect(order[1]).toBe('event')
-	})
-
-	it('response hook fires with the final response text', async () => {
-		let hookText: string | undefined
-		const assistant = makeAssistant({
-			response: async (_asst: any, text: string) => {
-				hookText = text
-			},
-		})
-		await startWithStub(assistant, /.*/, 'final answer')
-
-		await assistant.ask('question')
-		expect(hookText).toBe('final answer')
-	})
-})

package/test/assistant.test.ts

@@ -1,81 +0,0 @@
-import { describe, it, expect, beforeEach } from 'bun:test'
-import { AGIContainer } from '../src/agi/container.server'
-
-describe('Assistant', () => {
-	let container: AGIContainer
-
-	beforeEach(() => {
-		container = new AGIContainer()
-	})
-
-	describe('codingAssistant', () => {
-		it('loads a non-empty system prompt from CORE.md', () => {
-			const assistant = container.feature('assistant', { folder: 'assistants/codingAssistant' })
-			expect(assistant.systemPrompt.length).toBeGreaterThan(0)
-			expect(assistant.systemPrompt).toContain('coding assistant')
-		})
-
-		it('loads tools from codingTools feature after start', async () => {
-			const assistant = container.feature('assistant', {
-				folder: 'assistants/codingAssistant',
-				local: true,
-				model: 'qwen/qwen3-8b',
-			})
-			await assistant.start()
-			const tools = assistant.availableTools
-			expect(tools).toContain('rg')
-			expect(tools).toContain('ls')
-			expect(tools).toContain('cat')
-			expect(tools.length).toBeGreaterThan(0)
-		})
-
-		it('tools have descriptions and parameter schemas', async () => {
-			const assistant = container.feature('assistant', {
-				folder: 'assistants/codingAssistant',
-				local: true,
-				model: 'qwen/qwen3-8b',
-			})
-			await assistant.start()
-			const { rg, ls, cat } = assistant.tools
-			expect(rg.description.length).toBeGreaterThan(0)
-			expect(rg.parameters.type).toBe('object')
-			expect(rg.parameters.properties).toHaveProperty('args')
-			expect(ls.parameters.properties).toHaveProperty('args')
-			expect(cat.parameters.properties).toHaveProperty('args')
-		})
-
-		it('loads hooks from hooks.ts via the VM', () => {
-			const assistant = container.feature('assistant', { folder: 'assistants/codingAssistant' })
-			const hooks = assistant.state.get('hooks') as Record<string, Function>
-			expect(hooks).toBeDefined()
-			expect(typeof hooks.started).toBe('function')
-		})
-
-		it('hooks fire when the assistant starts', async () => {
-			const assistant = container.feature('assistant', {
-				folder: 'assistants/codingAssistant',
-				local: true,
-				model: 'qwen/qwen3-8b',
-			})
-
-			// triggerHook emits 'hookFired' with the hook name each time a hook runs
-			const fired: string[] = []
-			assistant.on('hookFired', (eventName: string) => { fired.push(eventName) })
-
-			await assistant.start()
-			expect(fired).toContain('started')
-		})
-
-		it('tools are wired into the conversation after start', async () => {
-			const assistant = container.feature('assistant', {
-				folder: 'assistants/codingAssistant',
-				local: true,
-				model: 'qwen/qwen3-8b',
-			})
-			await assistant.start()
-			const convTools = assistant.conversation.tools
-			expect(Object.keys(convTools)).toContain('rg')
-			expect(Object.keys(convTools)).toContain('ls')
-		})
-	})
-})

package/test/bus.test.ts

@@ -1,134 +0,0 @@
-import { describe, it, expect, mock, beforeEach, afterEach } from 'bun:test'
-import { Bus } from '../src/bus'
-
-describe('Bus', () => {
-  it('emits events to listeners', () => {
-    const bus = new Bus()
-    const listener = mock()
-    bus.on('test', listener)
-    bus.emit('test', 'arg1', 'arg2')
-    expect(listener).toHaveBeenCalledWith('arg1', 'arg2')
-  })
-
-  it('supports multiple listeners', () => {
-    const bus = new Bus()
-    const a = mock()
-    const b = mock()
-    bus.on('event', a)
-    bus.on('event', b)
-    bus.emit('event', 42)
-    expect(a).toHaveBeenCalledWith(42)
-    expect(b).toHaveBeenCalledWith(42)
-  })
-
-  it('off removes a specific listener', () => {
-    const bus = new Bus()
-    const listener = mock()
-    bus.on('test', listener)
-    bus.off('test', listener)
-    bus.emit('test')
-    expect(listener).not.toHaveBeenCalled()
-  })
-
-  it('off without listener removes all listeners for event', () => {
-    const bus = new Bus()
-    const a = mock()
-    const b = mock()
-    bus.on('test', a)
-    bus.on('test', b)
-    bus.off('test')
-    bus.emit('test')
-    expect(a).not.toHaveBeenCalled()
-    expect(b).not.toHaveBeenCalled()
-  })
-
-  it('once fires only once', () => {
-    const bus = new Bus()
-    const listener = mock()
-    bus.once('test', listener)
-    bus.emit('test', 'first')
-    bus.emit('test', 'second')
-    expect(listener).toHaveBeenCalledTimes(1)
-    expect(listener).toHaveBeenCalledWith('first')
-  })
-
-  it('waitFor returns a promise that resolves on emit', async () => {
-    const bus = new Bus()
-    const promise = bus.waitFor('done')
-    bus.emit('done', 'result')
-    const value = await promise
-    expect(value).toBe('result')
-  })
-
-  it('emit with no listeners does not throw', () => {
-    const bus = new Bus()
-    expect(() => bus.emit('nope')).not.toThrow()
-  })
-
-  describe('event stats tracking', () => {
-    it('tracks fire count for events', () => {
-      const bus = new Bus()
-      bus.emit('click')
-      bus.emit('click')
-      bus.emit('click')
-      const stats = bus.getEventStats('click')
-      expect(stats.fireCount).toBe(3)
-      expect(stats.event).toBe('click')
-    })
-
-    it('tracks lastFiredAt timestamp', () => {
-      const bus = new Bus()
-      const before = Date.now()
-      bus.emit('ping')
-      const after = Date.now()
-      const stats = bus.getEventStats('ping')
-      expect(stats.lastFiredAt).toBeGreaterThanOrEqual(before)
-      expect(stats.lastFiredAt).toBeLessThanOrEqual(after)
-    })
-
-    it('returns zero stats for events that never fired', () => {
-      const bus = new Bus()
-      const stats = bus.getEventStats('ghost')
-      expect(stats.fireCount).toBe(0)
-      expect(stats.lastFiredAt).toBeNull()
-      expect(stats.firesPerMinute).toBe(0)
-    })
-
-    it('history returns stats for all fired events', () => {
-      const bus = new Bus()
-      bus.emit('a')
-      bus.emit('b')
-      bus.emit('b')
-      bus.emit('c')
-      const history = bus.history
-      expect(history).toHaveLength(3)
-      expect(history.find(s => s.event === 'a')?.fireCount).toBe(1)
-      expect(history.find(s => s.event === 'b')?.fireCount).toBe(2)
-      expect(history.find(s => s.event === 'c')?.fireCount).toBe(1)
-    })
-
-    it('firedEvents lists all event names that have been emitted', () => {
-      const bus = new Bus()
-      bus.emit('x')
-      bus.emit('y')
-      bus.emit('x')
-      expect(bus.firedEvents).toEqual(['x', 'y'])
-    })
-
-    it('tracks events even with no listeners', () => {
-      const bus = new Bus()
-      bus.emit('orphan')
-      bus.emit('orphan')
-      expect(bus.getEventStats('orphan').fireCount).toBe(2)
-    })
-
-    it('computes firesPerMinute for recent events', () => {
-      const bus = new Bus()
-      bus.emit('rapid')
-      bus.emit('rapid')
-      bus.emit('rapid')
-      const stats = bus.getEventStats('rapid')
-      expect(stats.firesPerMinute).toBe(3)
-    })
-  })
-})