@soederpop/luca 0.0.2

package/scripts/update-introspection-data.ts

@@ -0,0 +1,58 @@
+/**
+ * Generates per-container introspection metadata files.
+ *
+ * Each container type gets its own generated file containing only the
+ * metadata relevant to that environment:
+ *
+ * - generated.node.ts: node features + servers
+ * - generated.web.ts: web features
+ * - generated.agi.ts: node features + servers + agi features
+ */
+import '../src/introspection/scan.js';
+import { NodeContainer } from '../src/node/container.js';
+
+const targets = [
+  {
+    name: 'node',
+    src: ['src/node/features', 'src/servers', 'src/container.ts', 'src/node/container.ts'],
+    outputPath: 'src/introspection/generated.node.ts',
+  },
+  {
+    name: 'web',
+    src: ['src/web/features', 'src/container.ts', 'src/web/container.ts'],
+    outputPath: 'src/introspection/generated.web.ts',
+  },
+  {
+    name: 'agi',
+    src: ['src/node/features', 'src/servers', 'src/agi/features', 'src/container.ts', 'src/node/container.ts', 'src/agi/container.server.ts'],
+    outputPath: 'src/introspection/generated.agi.ts',
+  },
+];
+
+async function main() {
+  const container = new NodeContainer();
+
+  for (const target of targets) {
+    console.log(`\n📦 Generating ${target.name} introspection data...`);
+    console.log(`   📁 Sources: ${target.src.join(', ')}`);
+    console.log(`   📄 Output: ${target.outputPath}`);
+
+    const scanner = container.feature('introspectionScanner', {
+      src: target.src,
+      outputPath: target.outputPath,
+    });
+
+    scanner.on('scanCompleted', (data) => {
+      console.log(`   ✅ Found ${data.results} helpers in ${data.files} files (${data.duration}ms)`);
+    });
+
+    await scanner.scan();
+    await scanner.generateRegistryScript();
+
+    console.log(`   📝 Wrote ${target.outputPath}`);
+  }
+
+  console.log('\n✨ All introspection data generated.');
+}
+
+main().catch(console.error);

package/src/agi/README.md

@@ -0,0 +1,14 @@
+# AGI Container
+
+The AGI Container is intended to support server and browser applications with an container
+object that provides dependencies, shared state, a global event bus, server and client instances, to instances of AI Agents.
+
+### Features
+
+## Claude Code Manager
+
+A JavaScript object you can `ask(question)` to a claude code session.  Observe its state, listen for events.
+
+## Expert
+
+An expert is something with system prompt, memory, and tool calls.  It is the base class for an agent that has access to the container and any of its features or components at runtime.  It maintains a conversation history and you can `ask(questions)` of it and get streaming responses.

package/src/agi/container.server.ts

@@ -0,0 +1,114 @@
+import type { ContainerState } from '@soederpop/luca/container'
+import { type NodeFeatures, NodeContainer } from '@soederpop/luca/node/container'
+import '@/introspection/generated.agi.js'
+import { OpenAIClient } from '../clients/openai'
+import { ElevenLabsClient } from '../clients/elevenlabs'
+import { ClaudeCode } from './features/claude-code'
+import { OpenAICodex } from './features/openai-codex'
+import { Conversation } from './features/conversation'
+import { SkillsLibrary } from './features/skills-library'
+import { ConversationHistory } from './features/conversation-history'
+import { Assistant } from './features/assistant'
+import { AssistantsManager } from './features/assistants-manager'
+import { SemanticSearch } from '@soederpop/luca/node/features/semantic-search'
+import { ContentDb } from '@soederpop/luca/node/features/content-db'
+
+import type { ConversationTool } from './features/conversation'
+import type { ZodType } from 'zod'
+
+export {
+	ClaudeCode,
+	OpenAICodex,
+	Conversation,
+	SkillsLibrary,
+	ConversationHistory,
+	Assistant,
+	AssistantsManager,
+	SemanticSearch,
+	ContentDb,
+	NodeContainer,
+	OpenAIClient,
+	ElevenLabsClient,
+}
+
+export type {
+	ConversationTool,
+	ZodType,
+	ContainerState,
+	NodeFeatures,
+}
+
+export interface ConversationFactoryOptions {
+	tools?: {
+		handlers: Record<string, ConversationTool['handler']>
+		schemas: Record<string, ZodType>
+	}
+	systemPrompt?: string
+	model?: string
+	id?: string
+	title?: string
+	thread?: string
+	tags?: string[]
+	metadata?: Record<string, any>
+}
+
+/**
+ * AGI-specific container that extends NodeContainer with AI capabilities including
+ * OpenAI conversations, code generation, and self-modifying agent features.
+ */
+export class AGIContainer extends NodeContainer {
+	openai!: OpenAIClient
+	claudeCode?: ClaudeCode
+	openaiCodex?: OpenAICodex
+	skillsLibrary?: SkillsLibrary
+	conversationHistory?: ConversationHistory
+	docs!: ContentDb
+
+	async conversation(options: ConversationFactoryOptions = {}) {
+		const tools: Record<string, ConversationTool> = {}
+
+		if (options.tools) {
+			for (const [name, schema] of Object.entries(options.tools.schemas)) {
+				const jsonSchema = (schema as any).toJSONSchema() as Record<string, any>
+				tools[name] = {
+					handler: options.tools.handlers[name]!,
+					description: jsonSchema.description || name,
+					parameters: jsonSchema,
+				}
+			}
+		}
+
+		const history = options.systemPrompt
+			? [{ role: 'system' as const, content: options.systemPrompt }]
+			: undefined
+
+		return this.feature('conversation', {
+			tools,
+			history,
+			model: options.model,
+			id: options.id,
+			title: options.title,
+			thread: options.thread,
+			tags: options.tags,
+			metadata: options.metadata,
+		})
+	}
+}
+
+const container = new AGIContainer()
+	.use(OpenAIClient)
+	.use(ElevenLabsClient)
+	.use(ClaudeCode)
+	.use(OpenAICodex)
+	.use(Conversation)
+	.use(SkillsLibrary)
+	.use(ConversationHistory)
+	.use(Assistant)
+	.use(AssistantsManager)
+	.use(SemanticSearch)
+
+container.docs = container.feature('contentDb', {
+	rootPath: container.paths.resolve('docs')
+})
+
+export default container

package/src/agi/endpoints/ask.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod'
+import type { EndpointContext } from '../../endpoint.js'
+
+export const path = '/ask'
+export const description = 'Ask the AGI container a question'
+export const tags = ['agi']
+
+export const postSchema = z.object({
+  question: z.string().describe('The question to ask'),
+  context: z.string().optional().describe('Additional context for the question'),
+  stream: z.boolean().optional().default(false).describe('Whether to stream the response'),
+})
+
+export async function post(
+  parameters: z.infer<typeof postSchema>,
+  ctx: EndpointContext
+) {
+  const { container } = ctx
+  const { question, context: userContext, stream } = parameters
+
+  const history: any[] = []
+  if (userContext) {
+    history.push({ role: 'system', content: userContext })
+  }
+
+  const conversation = container.feature('conversation' as any, {
+    history,
+  }) as any
+
+  if (stream) {
+    ctx.response.setHeader('Content-Type', 'text/event-stream')
+    ctx.response.setHeader('Cache-Control', 'no-cache')
+    ctx.response.setHeader('Connection', 'keep-alive')
+
+    conversation.on('chunk', (chunk: string) => {
+      ctx.response.write(`data: ${JSON.stringify({ chunk })}\n\n`)
+    })
+
+    const answer = await conversation.ask(question)
+    ctx.response.write(`data: ${JSON.stringify({ done: true, answer })}\n\n`)
+    ctx.response.end()
+    return
+  }
+
+  const answer = await conversation.ask(question)
+  return { answer }
+}
+
+export const getSchema = z.object({
+  question: z.string().describe('The question to ask'),
+})
+
+export async function get(
+  parameters: z.infer<typeof getSchema>,
+  ctx: EndpointContext
+) {
+  const conversation = ctx.container.feature('conversation' as any) as any
+  const answer = await conversation.ask(parameters.question)
+  return { answer }
+}

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

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

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

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