@soederpop/luca 0.1.2 → 0.2.1

package/commands/inkbot.ts

@@ -0,0 +1,353 @@
+import { z } from 'zod'
+import { commands, CommandOptionsSchema } from '@soederpop/luca'
+import type { ContainerContext } from '@soederpop/luca'
+import { AGIContainer } from '../src/agi/container.server.js'
+import { tmpdir } from 'os'
+
+export const argsSchema = CommandOptionsSchema.extend({
+  model: z.string().optional().describe('OpenAI model to use'),
+})
+
+export async function inkbot(options: z.infer<typeof argsSchema>, context: ContainerContext) {
+  const container = new AGIContainer()
+
+  // ─── Load Ink ────────────────────────────────────────────────────────
+  const ink = container.feature('ink', { enable: true, patchConsole: true })
+  await ink.loadModules()
+  const React = ink.React
+  const h = React.createElement
+  const { Box, Text } = ink.components
+  const { useInput, useApp, useStdout } = ink.hooks
+  const { useState, useEffect } = React
+
+  // ─── Scene Runner ────────────────────────────────────────────────────
+  // Scenes are code strings run as bun subprocesses.
+  // The stage entity tracks which scenes exist and which is active.
+  // Scene entities track individual code, output, error, status.
+
+  const stage = container.entity('inkbot:stage')
+  stage.setState({ activeSceneId: null, sceneIds: [] as string[], tick: 0 })
+
+  const sceneMap: Record<string, ReturnType<typeof container.entity>> = {}
+
+  function bumpStage() {
+    stage.setState({ tick: ((stage.state.get('tick') as number) || 0) + 1 })
+  }
+
+  function getOrCreateScene(id: string, code: string) {
+    if (sceneMap[id]) {
+      sceneMap[id].setState({ code })
+      return sceneMap[id]
+    }
+    const scene = container.entity(`inkbot:scene:${id}`)
+    scene.setState({ code, output: '', error: '', status: 'idle', exitCode: null })
+    sceneMap[id] = scene
+    const ids = [...((stage.state.get('sceneIds') || []) as string[])]
+    if (!ids.includes(id)) ids.push(id)
+    stage.setState({ sceneIds: ids })
+    if (!stage.state.get('activeSceneId')) stage.setState({ activeSceneId: id })
+    return scene
+  }
+
+  const proc = container.feature('proc')
+  const fs = container.feature('fs')
+  const sceneTmpDir = `${tmpdir()}/inkbot-scenes`
+  fs.ensureFolder(sceneTmpDir)
+
+  async function runScene(id: string): Promise<{ output: string; error: string; exitCode: number }> {
+    const scene = sceneMap[id]
+    if (!scene) throw new Error(`Scene "${id}" not found`)
+
+    const code = scene.state.get('code') as string
+    scene.setState({ status: 'running', output: '', error: '' })
+    bumpStage()
+
+    // Write to tmpdir, shell out to `luca run` — gets full container context + process isolation
+    const file = `${sceneTmpDir}/${id.replace(/[^a-zA-Z0-9-]/g, '_')}_${Date.now()}.ts`
+    fs.writeFile(file, code)
+
+    try {
+      const result = await proc.spawnAndCapture('luca', ['run', file], {
+        cwd: container.cwd,
+        onOutput(data: string) {
+          scene.setState({ output: ((scene.state.get('output') || '') as string) + data })
+          bumpStage()
+        },
+        onError(data: string) {
+          scene.setState({ error: ((scene.state.get('error') || '') as string) + data })
+          bumpStage()
+        },
+      })
+
+      const status = result.exitCode === 0 ? 'complete' : 'failed'
+      scene.setState({ status, exitCode: result.exitCode })
+      bumpStage()
+      try { fs.unlink(file) } catch {}
+
+      return {
+        output: (scene.state.get('output') || '') as string,
+        error: (scene.state.get('error') || '') as string,
+        exitCode: result.exitCode ?? 1,
+      }
+    } catch (err: any) {
+      scene.setState({ status: 'failed', error: err.message, exitCode: 1 })
+      bumpStage()
+      try { fs.unlink(file) } catch {}
+      return { output: '', error: err.message, exitCode: 1 }
+    }
+  }
+
+  // ─── Assistant ───────────────────────────────────────────────────────
+  const mgr = container.feature('assistantsManager')
+  await mgr.discover()
+  const assistant = mgr.create('inkbot', { model: options.model })
+
+  // Scene completion → inject result into conversation so the assistant sees it
+  stage.on('sceneComplete' as any, (id: string, output: string) => {
+    const msg = output.trim()
+      ? `[Scene "${id}" completed]\n${output.trim()}`
+      : `[Scene "${id}" completed with no output]`
+    assistant.conversation?.pushMessage({ role: 'developer', content: msg })
+  })
+
+  stage.on('sceneFailed' as any, (id: string, error: string) => {
+    const msg = `[Scene "${id}" failed]\n${error.trim()}`
+    assistant.conversation?.pushMessage({ role: 'developer', content: msg })
+    // Auto-ask the assistant to fix it
+    assistant.ask(msg).catch(() => {})
+  })
+
+  // Canvas tools — registered directly so they close over stage/sceneMap
+  assistant.addTool(
+    'draw',
+    async (args: { code: string; sceneId?: string }) => {
+      const id = args.sceneId || 'default'
+      getOrCreateScene(id, args.code)
+      stage.setState({ activeSceneId: id })
+      bumpStage()
+      // Fire and forget — result feeds back via stage events
+      runScene(id).then(result => {
+        if (result.exitCode === 0) {
+          stage.emit('sceneComplete' as any, id, result.output)
+        } else {
+          stage.emit('sceneFailed' as any, id, result.error)
+        }
+      })
+      return { status: 'running', sceneId: id }
+    },
+    z.object({
+      code: z.string().describe('TypeScript code to execute. Use console.log() for visible output.'),
+      sceneId: z.string().optional().describe('Scene id (defaults to "default").'),
+    }).describe('Draw or redraw the canvas. Returns immediately — output streams to the canvas. If the scene fails, you will be notified automatically.'),
+  )
+
+  assistant.addTool(
+    'create_scene',
+    async (args: { id: string; code: string }) => {
+      getOrCreateScene(args.id, args.code)
+      return { created: args.id, allScenes: stage.state.get('sceneIds') }
+    },
+    z.object({
+      id: z.string().describe('Unique scene identifier'),
+      code: z.string().describe('TypeScript code for this scene'),
+    }).describe('Create a named scene without running it yet.'),
+  )
+
+  assistant.addTool(
+    'run_scene',
+    async (args: { id: string }) => runScene(args.id),
+    z.object({
+      id: z.string().describe('Scene id to run'),
+    }).describe('Run a specific scene by its id.'),
+  )
+
+  assistant.addTool(
+    'run_all',
+    async () => {
+      const ids = (stage.state.get('sceneIds') || []) as string[]
+      const results: any[] = []
+      for (const id of ids) results.push({ id, ...(await runScene(id)) })
+      return results
+    },
+    z.object({}).describe('Run every scene in order and return all results.'),
+  )
+
+  assistant.addTool(
+    'get_canvas',
+    async () => {
+      const activeId = stage.state.get('activeSceneId') as string | null
+      if (!activeId || !sceneMap[activeId]) return { status: 'empty', allScenes: [] }
+      const s = sceneMap[activeId]
+      return {
+        sceneId: activeId,
+        status: s.state.get('status'),
+        output: s.state.get('output'),
+        error: s.state.get('error'),
+        code: s.state.get('code'),
+        allScenes: stage.state.get('sceneIds'),
+      }
+    },
+    z.object({}).describe('Inspect the current canvas: active scene output, error, code, status.'),
+  )
+
+  assistant.addTool(
+    'activate_scene',
+    async (args: { id: string }) => {
+      if (!sceneMap[args.id]) return { error: `Scene "${args.id}" not found` }
+      stage.setState({ activeSceneId: args.id })
+      bumpStage()
+      return { activeSceneId: args.id }
+    },
+    z.object({
+      id: z.string().describe('Scene id to make active in the canvas'),
+    }).describe('Switch the canvas to display a different scene.'),
+  )
+
+  // ─── Ink App ─────────────────────────────────────────────────────────
+
+  type Msg = { role: 'user' | 'assistant' | 'system'; content: string }
+
+  function App() {
+    const [messages, setMessages] = useState<Msg[]>([])
+    const [input, setInput] = useState('')
+    const [streaming, setStreaming] = useState('')
+    const [thinking, setThinking] = useState(false)
+    const [activity, setActivity] = useState('')
+    const [canvas, setCanvas] = useState({ output: '', error: '', status: 'empty' })
+    const { exit } = useApp()
+    const { stdout } = useStdout()
+    const rows = stdout?.rows ?? 24
+
+    // --- assistant events ---
+    useEffect(() => {
+      const onPreview = (text: string) => setStreaming(text)
+      const onResponse = (text: string) => {
+        setStreaming('')
+        setThinking(false)
+        setActivity('')
+        setMessages(prev => [...prev, { role: 'assistant', content: text }])
+      }
+      const onToolCall = (name: string) => setActivity(`${name}`)
+      const onToolResult = () => setActivity('')
+
+      assistant.on('preview', onPreview)
+      assistant.on('response', onResponse)
+      assistant.on('toolCall', onToolCall)
+      assistant.on('toolResult', onToolResult)
+      return () => {
+        assistant.off('preview', onPreview)
+        assistant.off('response', onResponse)
+        assistant.off('toolCall', onToolCall)
+        assistant.off('toolResult', onToolResult)
+      }
+    }, [])
+
+    // --- stage entity ticks → canvas state ---
+    useEffect(() => {
+      const unsub = stage.state.observe((_changeType: any, key: any) => {
+        if (key !== 'tick') return
+        const activeId = stage.state.get('activeSceneId') as string | null
+        if (!activeId || !sceneMap[activeId]) {
+          setCanvas({ output: '', error: '', status: 'empty' })
+          return
+        }
+        const s = sceneMap[activeId]
+        setCanvas({
+          output: (s.state.get('output') || '') as string,
+          error: (s.state.get('error') || '') as string,
+          status: (s.state.get('status') || 'idle') as string,
+        })
+      })
+      return unsub
+    }, [])
+
+    // --- keyboard ---
+    useInput((ch, key) => {
+      if (key.escape) { exit(); return }
+
+      if (key.return) {
+        if (thinking) return
+        const msg = input.trim()
+        if (!msg) return
+        setInput('')
+        setMessages(prev => [...prev, { role: 'user', content: msg }])
+        setThinking(true)
+        assistant.ask(msg).catch((err: any) => {
+          setMessages(prev => [...prev, { role: 'system', content: `error: ${err.message}` }])
+          setThinking(false)
+        })
+        return
+      }
+
+      if (key.backspace || key.delete) {
+        setInput(prev => prev.slice(0, -1))
+        return
+      }
+
+      if (ch && !key.ctrl && !key.meta) {
+        setInput(prev => prev + ch)
+      }
+    })
+
+    // --- render ---
+    const visible = messages.slice(-30)
+    const sceneIds = (stage.state.get('sceneIds') || []) as string[]
+    const activeId = (stage.state.get('activeSceneId') || '') as string
+
+    const chatChildren: any[] = []
+
+    visible.forEach((m, i) => {
+      const color = m.role === 'user' ? 'green' : m.role === 'system' ? 'red' : 'white'
+      const prefix = m.role === 'user' ? '> ' : '  '
+      chatChildren.push(h(Text, { key: `msg-${i}`, wrap: 'wrap', color }, `${prefix}${m.content}`))
+    })
+
+    if (streaming) chatChildren.push(h(Text, { key: 'chat-stream', wrap: 'wrap', dimColor: true }, `  ${streaming}`))
+    if (thinking && !streaming) chatChildren.push(h(Text, { key: 'chat-think', color: 'yellow' }, '  thinking...'))
+    if (activity) chatChildren.push(h(Text, { key: 'chat-act', color: 'blue' }, `  [${activity}]`))
+
+    const canvasBody = canvas.output
+      ? h(Text, { key: 'cvs-out', wrap: 'wrap' }, canvas.output)
+      : canvas.status === 'empty'
+        ? h(Text, { key: 'cvs-empty', dimColor: true }, '  ask inkbot to draw something')
+        : null
+
+    // border + header + status = 4 rows overhead per panel
+    const panelHeight = rows - 2
+
+    return h(Box, { flexDirection: 'row', width: '100%', height: rows },
+      // ── Chat ──
+      h(Box, { key: 'chat', flexDirection: 'column', width: '50%', height: rows, borderStyle: 'round', borderColor: 'cyan', paddingX: 1 },
+        h(Text, { bold: true, color: 'cyan' }, ' inkbot '),
+        h(Box, { flexDirection: 'column', flexGrow: 1, overflow: 'hidden' }, ...chatChildren),
+        h(Box, { borderStyle: 'single', borderColor: 'gray', paddingX: 1 },
+          h(Text, { color: 'green' }, '> '),
+          h(Text, null, input),
+          h(Text, { dimColor: true }, '\u2588'),
+        ),
+      ),
+      // ── Canvas ──
+      h(Box, { key: 'canvas', flexDirection: 'column', width: '50%', height: rows, borderStyle: 'round', borderColor: 'magenta', paddingX: 1 },
+        h(Text, { bold: true, color: 'magenta' }, ' canvas '),
+        h(Box, { flexDirection: 'column', height: panelHeight - 4, overflow: 'hidden' },
+          canvasBody,
+          canvas.error ? h(Text, { key: 'cvs-err', color: 'red', wrap: 'wrap' }, canvas.error) : null,
+        ),
+        h(Box, null,
+          h(Text, { dimColor: true }, ` ${canvas.status}`),
+          sceneIds.length > 1 ? h(Text, { dimColor: true }, `  scenes: ${sceneIds.join(', ')}  active: ${activeId}`) : null,
+        ),
+      ),
+    )
+  }
+
+  // Mount and hold
+  await ink.render(h(App))
+  await ink.waitUntilExit()
+}
+
+export default {
+  description: 'Launch the Inkbot split-pane assistant with a live canvas.',
+  argsSchema,
+  handler: inkbot,
+}

package/commands/release.ts

@@ -1,186 +1,80 @@
-import { z } from 'zod'
-import type { ContainerContext } from '@soederpop/luca'
-import { CommandOptionsSchema } from '@soederpop/luca/schemas'
-
-const TARGETS = [
-	{ name: 'linux-x64', bunTarget: 'bun-linux-x64', suffix: 'linux-x64' },
-	{ name: 'linux-arm64', bunTarget: 'bun-linux-arm64', suffix: 'linux-arm64' },
-	{ name: 'darwin-x64', bunTarget: 'bun-darwin-x64', suffix: 'darwin-x64' },
-	{ name: 'darwin-arm64', bunTarget: 'bun-darwin-arm64', suffix: 'darwin-arm64' },
-	{ name: 'windows-x64', bunTarget: 'bun-windows-x64', suffix: 'windows-x64', ext: '.exe' },
-]
+import { z } from "zod";
+import type { ContainerContext } from "@soederpop/luca";
+import { CommandOptionsSchema } from "@soederpop/luca/schemas";
 
 export const argsSchema = CommandOptionsSchema.extend({
-	dryRun: z.boolean().optional().describe('Build binaries but skip tagging and uploading'),
-	skipBuild: z.boolean().optional().describe('Skip pre-build steps (introspection, scaffolds, bootstrap)'),
-	skipTests: z.boolean().optional().describe('Skip running tests before release'),
-	draft: z.boolean().optional().describe('Create the GitHub release as a draft'),
-	targets: z.string().optional().describe('Comma-separated list of targets to build (e.g. linux-x64,darwin-arm64). Defaults to all'),
-})
-
-async function release(options: z.infer<typeof argsSchema>, context: ContainerContext) {
-	const container = context.container as any
-	const proc = container.feature('proc')
-	const fileSystem = container.feature('fs')
-	const ui = container.feature('ui')
-
-	const pkg = JSON.parse(await fileSystem.readFileAsync('package.json'))
-	const version = pkg.version
-	const tag = `v${version}`
-	const distDir = 'dist/release'
-
-	ui.banner(`Luca Release ${tag}`)
-
-	// Filter targets if specified
-	let selectedTargets = TARGETS
-	if (options.targets) {
-		const requested = options.targets.split(',').map((t: string) => t.trim())
-		selectedTargets = TARGETS.filter(t => requested.includes(t.suffix) || requested.includes(t.name))
-		if (selectedTargets.length === 0) {
-			console.error(`No valid targets found. Available: ${TARGETS.map(t => t.suffix).join(', ')}`)
-			return
-		}
-	}
-
-	// 1. Run tests
-	if (!options.skipTests) {
-		console.log('\n→ Running tests...')
-		const testResult = await proc.execAndCapture('bun test test/*.test.ts', { silent: false })
-		if (testResult.exitCode !== 0) {
-			console.error('Tests failed. Fix them before releasing.')
-			return
-		}
-	}
-
-	// 2. Pre-build steps
-	if (!options.skipBuild) {
-		console.log('\n→ Running pre-build steps...')
-		const steps = [
-			['build:introspection', 'bun run build:introspection'],
-			['build:scaffolds', 'bun run build:scaffolds'],
-			['build:bootstrap', 'bun run build:bootstrap'],
-		]
-		for (const [label, cmd] of steps) {
-			console.log(`  ${label}...`)
-			const r = await proc.execAndCapture(cmd, { silent: true })
-			if (r.exitCode !== 0) {
-				console.error(`${label} failed:\n${r.stderr}`)
-				return
-			}
-		}
-	}
-
-	// 3. Cross-compile for all targets
-	fileSystem.ensureFolder(distDir)
-
-	console.log(`\n→ Compiling for ${selectedTargets.length} targets...`)
-	for (const target of selectedTargets) {
-		const ext = target.ext || ''
-		const outfile = `${distDir}/luca-${target.suffix}${ext}`
-		const cmd = `bun build ./src/cli/cli.ts --compile --target=${target.bunTarget} --outfile ${outfile} --external node-llama-cpp`
-
-		console.log(`  ${target.name}...`)
-		const result = await proc.execAndCapture(cmd, { silent: true })
-		if (result.exitCode !== 0) {
-			console.error(`  Failed to compile for ${target.name}:\n${result.stderr}`)
-			return
-		}
-
-		const sizeBytes = proc.exec(`stat -f%z ${container.paths.resolve(outfile)}`)
-		const sizeMB = (parseInt(sizeBytes, 10) / 1024 / 1024).toFixed(1)
-		console.log(`  ✓ ${outfile} (${sizeMB} MB)`)
-	}
-
-	if (options.dryRun) {
-		console.log(`\n→ Dry run complete. Binaries are in ${distDir}/`)
-		console.log('  Skipping git tag and GitHub release.')
-		return
-	}
-
-	// 4. Check if tag already exists
-	const tagCheck = await proc.execAndCapture(`git tag -l "${tag}"`, { silent: true })
-	if (tagCheck.stdout.trim() === tag) {
-		console.error(`\nTag ${tag} already exists. Bump the version in package.json first.`)
-		return
-	}
-
-	// 5. Check for clean working tree (allow untracked)
-	const statusCheck = await proc.execAndCapture('git status --porcelain', { silent: true })
-	const dirtyFiles = statusCheck.stdout.trim().split('\n').filter((l: string) => l && !l.startsWith('??'))
-	if (dirtyFiles.length > 0) {
-		console.error('\nWorking tree has uncommitted changes. Commit or stash them first.')
-		console.error(dirtyFiles.join('\n'))
-		return
-	}
-
-	// 6. Create git tag
-	console.log(`\n→ Creating tag ${tag}...`)
-	const tagResult = await proc.execAndCapture(`git tag -a "${tag}" -m "Release ${tag}"`, { silent: true })
-	if (tagResult.exitCode !== 0) {
-		console.error(`Failed to create tag:\n${tagResult.stderr}`)
-		return
-	}
-
-	// 7. Push tag
-	console.log(`→ Pushing tag ${tag}...`)
-	const pushResult = await proc.execAndCapture(`git push origin "${tag}"`, { silent: true })
-	if (pushResult.exitCode !== 0) {
-		console.error(`Failed to push tag:\n${pushResult.stderr}`)
-		return
-	}
-
-	// 8. Create GitHub release and upload binaries
-	const assetPaths = selectedTargets
-		.map(t => container.paths.resolve(`${distDir}/luca-${t.suffix}${t.ext || ''}`))
-
-	const releaseTitle = `Luca ${tag}`
-	const releaseNotes = await generateReleaseNotes(proc, tag)
-
-	// Write notes to a temp file so gh doesn't need shell quoting
-	const notesFile = container.paths.resolve(distDir, 'release-notes.md')
-	await fileSystem.writeFileAsync(notesFile, releaseNotes)
-
-	console.log(`\n→ Creating GitHub release ${tag}...`)
-	const ghArgs = [
-		'release', 'create', tag,
-		...assetPaths,
-		'--title', releaseTitle,
-		'--notes-file', notesFile,
-		...(options.draft ? ['--draft'] : []),
-	]
-	const ghResult = await proc.spawnAndCapture('gh', ghArgs)
-
-	if (ghResult.exitCode !== 0) {
-		console.error(`Failed to create GitHub release:\n${ghResult.stderr}`)
-		console.log('The tag was pushed. You can manually create the release with:')
-		console.log(`  gh release create ${tag} ${assetPaths.join(' ')}`)
-		return
-	}
-
-	console.log(`\n✓ Released ${tag} successfully!`)
-	console.log(`  https://github.com/soederpop/luca/releases/tag/${tag}`)
-}
-
-async function generateReleaseNotes(proc: any, tag: string): Promise<string> {
-	// Get commits since last tag
-	const lastTag = await proc.execAndCapture('git describe --tags --abbrev=0 HEAD^ 2>/dev/null || echo ""', { silent: true })
-	const since = lastTag.stdout.trim()
-
-	let logCmd: string
-	if (since) {
-		logCmd = `git log ${since}..HEAD --oneline --no-decorate`
-	} else {
-		logCmd = 'git log --oneline --no-decorate -20'
-	}
-
-	const log = await proc.execAndCapture(logCmd, { silent: true })
-	const commits = log.stdout.trim()
-
-	return `## What's Changed\n\n${commits ? commits.split('\n').map((c: string) => `- ${c}`).join('\n') : 'Initial release'}\n\n## Platforms\n\n- Linux x64\n- Linux ARM64\n- macOS x64 (Intel)\n- macOS ARM64 (Apple Silicon)\n- Windows x64`
+  skipTests: z
+    .boolean()
+    .optional()
+    .describe("Skip running tests before release"),
+});
+
+async function release(
+  options: z.infer<typeof argsSchema>,
+  context: ContainerContext,
+) {
+  const container = context.container as any;
+  const proc = container.feature("proc");
+  const fileSystem = container.feature("fs");
+  const ui = container.feature("ui");
+
+  const pkg = JSON.parse(await fileSystem.readFileAsync("package.json"));
+  const version = pkg.version;
+  const tag = `v${version}`;
+
+  ui.banner(`Luca Release ${tag}`);
+
+  // Check if tag already exists
+  const tagCheck = await proc.execAndCapture(`git tag -l "${tag}"`, {
+    silent: true,
+  });
+  if (tagCheck.stdout.trim() === tag) {
+    console.error(
+      `\nTag ${tag} already exists. Bump the version in package.json first.`,
+    );
+    return;
+  }
+
+  // Run tests
+  if (!options.skipTests) {
+    console.log("\n→ Running tests...");
+    const testResult = await proc.execAndCapture("bun test test/*.test.ts", {
+      silent: false,
+    });
+    if (testResult.exitCode !== 0) {
+      console.error("Tests failed. Fix them before releasing.");
+      return;
+    }
+  }
+
+  // Create and push git tag — triggers the GitHub Actions release workflow
+  console.log(`\n→ Creating tag ${tag}...`);
+  const tagResult = await proc.execAndCapture(
+    `git tag -a "${tag}" -m "Release ${tag}"`,
+    { silent: true },
+  );
+  if (tagResult.exitCode !== 0) {
+    console.error(`Failed to create tag:\n${tagResult.stderr}`);
+    return;
+  }
+
+  console.log(`→ Pushing tag ${tag}...`);
+  const pushResult = await proc.execAndCapture(`git push origin "${tag}"`, {
+    silent: true,
+  });
+  if (pushResult.exitCode !== 0) {
+    console.error(`Failed to push tag:\n${pushResult.stderr}`);
+    return;
+  }
+
+  console.log(
+    `\n✓ Tag ${tag} pushed. GitHub Actions will build, sign, and create the draft release.`,
+  );
+  console.log(`  https://github.com/soederpop/luca/actions`);
 }
 
 export default {
-	description: 'Build cross-platform binaries and publish a GitHub release tagged by version',
-	argsSchema,
-	handler: release,
-}
+  description: "Run tests and trigger a GitHub Actions release via git tag",
+  argsSchema,
+  handler: release,
+};

package/dist/agi/container.server.d.ts

@@ -0,0 +1,63 @@
+import type { ContainerState } from '../container';
+import { type NodeFeatures, NodeContainer } from '../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 { ConversationHistory } from './features/conversation-history';
+import { Assistant } from './features/assistant';
+import { AssistantsManager } from './features/assistants-manager';
+import { DocsReader } from './features/docs-reader';
+import { SkillsLibrary } from './features/skills-library';
+import { BrowserUse } from './features/browser-use';
+import { SemanticSearch } from '@soederpop/luca/node/features/semantic-search';
+import { ContentDb } from '@soederpop/luca/node/features/content-db';
+import { FileTools } from './features/file-tools';
+import { LucaCoder } from './features/luca-coder';
+import type { ConversationTool } from './features/conversation';
+import type { ZodType } from 'zod';
+export { ClaudeCode, OpenAICodex, Conversation, ConversationHistory, Assistant, AssistantsManager, DocsReader, SkillsLibrary, BrowserUse, FileTools, LucaCoder, SemanticSearch, ContentDb, NodeContainer, OpenAIClient, ElevenLabsClient, };
+export type { ConversationTool, ZodType, ContainerState, NodeFeatures, };
+export interface AGIFeatures extends NodeFeatures {
+    conversation: typeof Conversation;
+    claudeCode: typeof ClaudeCode;
+    openaiCodex: typeof OpenAICodex;
+    conversationHistory: typeof ConversationHistory;
+    assistant: typeof Assistant;
+    assistantsManager: typeof AssistantsManager;
+    docsReader: typeof DocsReader;
+    skillsLibrary: typeof SkillsLibrary;
+    browserUse: typeof BrowserUse;
+    fileTools: typeof FileTools;
+    lucaCoder: typeof LucaCoder;
+}
+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 declare class AGIContainer<Features extends AGIFeatures = AGIFeatures, K extends ContainerState = ContainerState> extends NodeContainer<Features, K> {
+    openai: OpenAIClient;
+    claudeCode?: ClaudeCode;
+    openaiCodex?: OpenAICodex;
+    conversationHistory?: ConversationHistory;
+    docs: ContentDb;
+    conversation(options?: ConversationFactoryOptions): Promise<InstanceType<Features["conversation"]>>;
+}
+declare const container: any;
+export default container;
+//# sourceMappingURL=container.server.d.ts.map