luca 2.0.0 → 3.0.2

package/pyproject.toml

@@ -0,0 +1,7 @@
+[project]
+name = "luca2"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = []

package/scripts/build-web.ts

@@ -0,0 +1,28 @@
+// @ts-nocheck
+import path from "path"
+
+const result = await Bun.build({
+  entrypoints: [path.resolve(import.meta.dir, "../src/browser.ts")],
+  outdir: path.resolve(import.meta.dir, "../dist"),
+  target: "browser",
+  format: "esm",
+  naming: "browser.js",
+  external: [
+    "react",
+    "react-dom",
+  ],
+  define: {
+    "process.env.NODE_ENV": JSON.stringify("production"),
+    "process.env.NODE_DEBUG": JSON.stringify(""),
+  },
+})
+
+if (!result.success) {
+  console.error("Build failed:")
+  for (const log of result.logs) {
+    console.error(log)
+  }
+  process.exit(1)
+}
+
+console.log(`Built browser bundle: dist/browser.js (${(result.outputs[0].size / 1024).toFixed(1)}KB)`)

package/scripts/examples/ask-luca-expert.ts

@@ -0,0 +1,42 @@
+import container from 'luca/agi'
+import * as readline from 'readline'
+
+const { ui } = container
+
+const assistant = container.feature('assistant', {
+  folder: 'assistants/luca-expert',
+  model: 'gpt-5.2',
+})
+
+assistant.on('preview', (text: string) => {
+  process.stdout.write('\x1B[2J\x1B[H')
+  console.log(ui.markdown(text))
+})
+
+assistant.on('toolCall', (name: string, args: any) => {
+  process.stdout.write(ui.colors.dim(`\n  ⟳ ${name}(${JSON.stringify(args).slice(0, 80)})\n`))
+})
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+})
+
+function prompt(): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(ui.colors.dim('\nluca-expert > '), (answer) => resolve(answer.trim()))
+  })
+}
+
+console.log(ui.colors.dim('Ask the Luca expert anything. Type .exit to quit.\n'))
+
+while (true) {
+  const question = await prompt()
+
+  if (!question) continue
+  if (question === '.exit') break
+
+  await assistant.ask(question)
+}
+
+rl.close()

package/scripts/examples/assistant-questions.ts

@@ -0,0 +1,12 @@
+import container from 'luca/agi'
+
+const assistant = container.feature('assistant', {
+  folder: 'assistants/example',
+  appendPrompt: 'Always be brief. Search your internal docs to make sure you have all the info you need.',
+	prependPrompt: 'You are speaking to a gentleman named Jon aka Soederpop aka J-Money.',
+  model: 'gpt-4.1',
+})
+
+const secretAnswer = await assistant.ask('Research your internal docs before answering, what is the best city on earth?  Tell me that as well as the current time.  Make sure to greet me by name.')
+
+console.log(container.ui.markdown(secretAnswer))

package/scripts/examples/excalidraw-expert.ts

@@ -0,0 +1,75 @@
+/**
+ * Excalidraw Expert Demo
+ *
+ * Generates diagrams using the Excalidraw expert, which can:
+ * - Generate Excalidraw JSON diagrams from natural language
+ * - Render them to PNG images
+ * - Evaluate quality using OpenAI vision
+ * - Iterate to improve
+ *
+ * Usage:
+ *   bun run scripts/examples/excalidraw-expert.ts
+ *   bun run scripts/examples/excalidraw-expert.ts "a microservices architecture with api gateway"
+ *   bun run scripts/examples/excalidraw-expert.ts "user auth flow" --style blueprint
+ */
+import container from 'luca/agi/container.server'
+
+const args = process.argv.slice(2)
+const styleFlag = args.indexOf('--style')
+const style = styleFlag !== -1 ? args[styleFlag + 1] : undefined
+const prompt = args.filter((a, i) => a !== '--style' && (styleFlag === -1 || i !== styleFlag + 1)).join(' ')
+
+const description = prompt || 'A simple flowchart showing a user login process: user enters credentials, system validates, if valid show dashboard, if invalid show error and retry'
+
+async function main() {
+	const ui = container.feature('ui')
+
+	ui.banner('Excalidraw Expert', { font: 'Small', colors: ['cyan', 'blue'] })
+	console.log()
+
+	const expert = container.feature('expert', { name: 'excalidraw', folder: 'excalidraw' })
+
+	// Listen to events for live feedback
+	expert.on('preview' as any, (chunk: string) => {
+		process.stdout.write('.')
+	})
+
+	expert.on('toolCall' as any, (name: string, args: any) => {
+		console.log(`\n${ui.colors.cyan(`> ${name}`)}`)
+	})
+
+	expert.on('toolResult' as any, (name: string, result: string) => {
+		try {
+			const parsed = JSON.parse(result)
+			if (parsed.pngPath) {
+				console.log(ui.colors.green(`  Rendered: ${parsed.pngPath}`))
+			}
+			if (parsed.overall !== undefined) {
+				const score = parsed.overall
+				const color = score >= 4 ? 'green' : score >= 3 ? 'yellow' : 'red'
+				console.log(ui.colors[color](`  Quality score: ${score}/5`))
+			}
+		} catch {}
+	})
+
+	const styleStr = style ? ` Use the "${style}" style.` : ''
+	const question = `Create a diagram for: ${description}.${styleStr}
+
+After generating it, evaluate the diagram and if it needs improvement, revise it. Aim for a quality score of 4 or higher on all dimensions.`
+
+	console.log(ui.colors.dim(`Prompt: ${question}\n`))
+	console.log(ui.colors.dim('Generating'))
+
+	const answer = await expert.ask(question)
+
+	console.log('\n')
+	console.log(answer)
+	console.log()
+
+	const outputDir = container.paths.resolve('experts', 'excalidraw', 'output')
+	console.log(ui.colors.dim(`\nOutput files in: ${outputDir}`))
+	console.log(ui.colors.dim('Open diagram.excalidraw in https://excalidraw.com to edit'))
+	console.log(ui.colors.dim('View diagram.png for the rendered image'))
+}
+
+main().catch(console.error)

package/scripts/examples/file-manager.ts

@@ -0,0 +1,14 @@
+import container from 'luca/agi'
+
+async function main() {
+const fileManager = await container.feature('fileManager').enable()
+await fileManager.start()
+
+const fileIds = fileManager.fileIds
+const typescriptFiles = fileManager.matchFiles("**/*.ts")
+
+console.log(fileIds)
+console.log(typescriptFiles)
+}
+
+main()

package/scripts/examples/ideas.ts

@@ -0,0 +1,12 @@
+import container from 'luca/agi'
+// @ts-ignore - module not yet implemented
+import createCollection, { Idea } from '@/ideas'
+
+async function main() {
+	const collection = await createCollection(container.paths.resolve('docs'))
+ 	const ideas =	await collection.query(Idea).fetchAll()
+	
+	console.log(ideas.map((i: any) => i.sections.motivation))
+}
+
+main()

package/scripts/examples/interactive-chat.ts

@@ -0,0 +1,20 @@
+import container from 'luca/agi'
+
+const { ui } = container
+
+async function main() {
+	const conversation = container.feature('conversation', {
+		model: 'gpt-4o-mini',
+	})
+
+	conversation.on('preview', (chunk: string) => {
+		console.clear()
+		console.log(
+			ui.markdown(chunk)
+		)
+	})
+
+	const result = await conversation.ask("Explain typescript module augmentation")
+}
+
+main()

package/scripts/examples/openai-tool-calls.ts

@@ -0,0 +1,113 @@
+/**
+ * Demonstrates OpenAI tool calls with gpt-5 using the raw openai SDK.
+ *
+ * Asks the model to compute a precise math expression — something it
+ * fundamentally cannot do reliably without calling the calculator tool.
+ * This guarantees a tool call on every run.
+ *
+ * Usage: bun run scripts/examples/openai-tool-calls.ts
+ */
+import OpenAI from "openai";
+
+const client = new OpenAI(); // uses OPENAI_API_KEY from env
+
+// Define a calculator tool
+const tools: OpenAI.Chat.Completions.ChatCompletionTool[] = [
+  {
+    type: "function",
+    function: {
+      name: "calculate",
+      description:
+        "Evaluate a mathematical expression and return the exact numeric result. You MUST use this tool for any arithmetic — do not attempt to compute in your head.",
+      parameters: {
+        type: "object",
+        properties: {
+          expression: {
+            type: "string",
+            description:
+              'The math expression to evaluate, e.g. "(1337 * 7919) + 42"',
+          },
+        },
+        required: ["expression"],
+      },
+    },
+  },
+];
+
+// A prompt that forces tool use — precise arithmetic the model can't fake
+const messages: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [
+  {
+    role: "system",
+    content:
+      "You are a precise math assistant. Always use the calculate tool for arithmetic. Never guess.",
+  },
+  {
+    role: "user",
+    content:
+      "What is (7823 * 4519) + (1337 ^ 3) - 98765? Show the intermediate steps.",
+  },
+];
+
+async function run() {
+  const conversation: OpenAI.Chat.Completions.ChatCompletionMessageParam[] = [...messages];
+  let round = 0;
+
+  // Loop until the model stops calling tools
+  while (true) {
+    round++;
+    console.log(`--- Round ${round}: sending request to gpt-5 ---\n`);
+
+    const response = await client.chat.completions.create({
+      model: "gpt-5",
+      messages: conversation,
+      tools,
+      tool_choice: "auto",
+    });
+
+    const choice = response.choices[0]!;
+    const assistantMessage = choice.message;
+
+    console.log("Finish reason:", choice.finish_reason);
+    console.log("Tool calls:", assistantMessage.tool_calls?.length ?? 0, "\n");
+
+    // Append assistant message to conversation history
+    conversation.push(assistantMessage);
+
+    // Done — model gave a final text response
+    if (choice.finish_reason === "stop") {
+      console.log("Final answer:\n");
+      console.log(assistantMessage.content);
+      break;
+    }
+
+    if (!assistantMessage.tool_calls?.length) {
+      console.log("Unexpected state — no tool calls but finish_reason:", choice.finish_reason);
+      console.log(JSON.stringify(choice, null, 2));
+      break;
+    }
+
+    // Execute each tool call and append results to conversation
+    for (const toolCall of assistantMessage.tool_calls) {
+      const args = JSON.parse(toolCall.function.arguments);
+      console.log(`Tool call: ${toolCall.function.name}("${args.expression}")`);
+
+      let result: string;
+      try {
+        const fn = new Function(`return (${args.expression})`);
+        result = String(fn());
+      } catch (e: any) {
+        result = `Error: ${e.message}`;
+      }
+
+      console.log(`  => ${result}\n`);
+
+      conversation.push({
+        role: "tool",
+        tool_call_id: toolCall.id,
+        content: result,
+      });
+    }
+  }
+}
+
+run().catch(console.error);

package/scripts/examples/opening-a-web-browser.ts

@@ -0,0 +1,5 @@
+import container from 'luca/node'
+
+const opener = container.feature('opener')
+
+await opener.open('https://www.google.com')

package/scripts/examples/telegram-bot.ts

@@ -0,0 +1,79 @@
+import container from 'luca/node'
+
+const ui = container.feature('ui')
+const tg = container.feature('telegram', {
+  autoStart: false,
+  mode: 'polling',
+  webhookPath: '/telegram/webhook',
+  pollingTimeout: 1,
+})
+
+function nowStamp(): string {
+  const dt = new Date()
+  const hh = String(dt.getHours()).padStart(2, '0')
+  const mm = String(dt.getMinutes()).padStart(2, '0')
+  const ss = String(dt.getSeconds()).padStart(2, '0')
+  return `${hh}:${mm}:${ss}`
+}
+
+function log(line: string, color = 'white') {
+  const stamp = ui.colors.dim(`[${nowStamp()}]`)
+  const palette = ui.colors as any
+  const painter = typeof palette[color] === 'function' ? palette[color] : ((value: string) => value)
+  console.log(`${stamp} ${painter(line)}`)
+}
+
+tg.command('start', async (ctx) => {
+  await ctx.reply('Neon channel online. Send any text and I will echo it back.')
+})
+
+tg.command('status', async (ctx) => {
+  await ctx.reply(`running=${tg.isRunning} mode=${tg.mode}`)
+})
+
+tg.handle('message:text', async (ctx) => {
+  const text = (ctx.message as any)?.text || ''
+  const from = ctx.from?.username ? `@${ctx.from.username}` : String(ctx.from?.id || 'unknown')
+  log(`message from ${from}: ${text}`, 'cyan')
+  await ctx.reply(`echo: ${text}`)
+})
+
+tg.on('error', (err: any) => {
+  log(`telegram error: ${err?.message || String(err)}`, 'red')
+})
+
+tg.on('command', (name: string, ctx: any) => {
+  const from = ctx?.from?.username ? `@${ctx.from.username}` : String(ctx?.from?.id || 'unknown')
+  log(`command /${name} by ${from}`, 'yellow')
+})
+
+process.on('SIGINT', async () => {
+  log('shutting down telegram bot (SIGINT)', 'yellow')
+  await tg.stop()
+  process.exit(0)
+})
+
+process.on('SIGTERM', async () => {
+  log('shutting down telegram bot (SIGTERM)', 'yellow')
+  await tg.stop()
+  process.exit(0)
+})
+
+async function main() {
+  log('starting telegram bot feature...', 'green')
+  await tg.enable()
+  await tg.start()
+
+  const botInfo = tg.state.get('botInfo')
+  if (botInfo?.username) {
+    log(`bot is live as @${botInfo.username}`, 'green')
+  }
+
+  log('awaiting telegram updates...', 'magenta')
+
+  await new Promise<void>(() => {
+    // keep process alive while grammY polling runs
+  })
+}
+
+await main()