luca 2.0.0 → 3.0.2

package/src/commands/code.ts

@@ -0,0 +1,371 @@
+import { z } from 'zod'
+import * as readline from 'readline'
+import { commands } from '../command.js'
+import { CommandOptionsSchema } from '../schemas/base.js'
+import type { ContainerContext } from '../container.js'
+import type { AGIContainer, AGIFeatures } from '../agi/container.server.js'
+
+declare module '../command.js' {
+	interface AvailableCommands {
+		code: ReturnType<typeof commands.registerHandler>
+	}
+}
+
+export const argsSchema = CommandOptionsSchema.extend({
+	model: z.string().optional().describe('Override the LLM model'),
+	local: z.boolean().default(false).describe('Use a local API server'),
+	prompt: z.string().optional().describe('Path to a markdown file or inline text for the system prompt'),
+	allowAll: z.boolean().default(false).describe('Start with all permissions set to allow (fully autonomous)'),
+	denyWrites: z.boolean().default(false).describe('Deny all write/delete/move operations'),
+	skills: z.string().optional().describe('Comma-separated list of additional skill names to load'),
+})
+
+export const positionals = ['prompt']
+
+export default async function code(options: z.infer<typeof argsSchema>, context: ContainerContext<AGIFeatures>) {
+	const container = context.container as AGIContainer
+	const ui = container.feature('ui')
+	const colors = ui.colors
+	const fs = container.feature('fs')
+
+	// ── Resolve system prompt ──────────────────────────────────────────────
+	// The lucaCoder feature has a solid default system prompt. Only override
+	// if the user explicitly provides one via --prompt.
+	let systemPrompt: string | undefined
+
+	if (options.prompt) {
+		const resolved = container.paths.resolve(options.prompt)
+		if (fs.exists(resolved)) {
+			systemPrompt = String(fs.readFile(resolved))
+		} else if (!options.prompt.endsWith('.md')) {
+			systemPrompt = options.prompt
+		} else {
+			console.error(colors.red(`File not found: ${resolved}`))
+			process.exit(1)
+		}
+	}
+
+	// ── Permission profile ─────────────────────────────────────────────────
+	const readTools = ['readFile', 'searchFiles', 'findFiles', 'listDirectory', 'fileInfo']
+	const writeTools = ['writeFile', 'editFile', 'createDirectory', 'moveFile', 'copyFile', 'bash']
+	const dangerTools = ['deleteFile']
+	const skillTools = ['searchAvailableSkills', 'loadSkill', 'askSkillBasedQuestion']
+
+	const permissions: Record<string, 'allow' | 'ask' | 'deny'> = {}
+
+	// Skill tools are always allowed — they're read-only discovery operations
+	for (const t of skillTools) permissions[t] = 'allow'
+
+	if (options.allowAll) {
+		for (const t of [...readTools, ...writeTools, ...dangerTools]) permissions[t] = 'allow'
+	} else if (options.denyWrites) {
+		for (const t of readTools) permissions[t] = 'allow'
+		for (const t of writeTools) permissions[t] = 'deny'
+		for (const t of dangerTools) permissions[t] = 'deny'
+	} else {
+		// Default: reads are free, writes need approval, danger is denied
+		for (const t of readTools) permissions[t] = 'allow'
+		for (const t of writeTools) permissions[t] = 'ask'
+		for (const t of dangerTools) permissions[t] = 'deny'
+	}
+
+	// ── Parse extra skills ────────────────────────────────────────────────
+	const extraSkills = options.skills ? options.skills.split(',').map((s: string) => s.trim()).filter(Boolean) : undefined
+
+	// ── Create the luca coder ──────────────────────────────────────────────
+	const coder = container.feature('lucaCoder', {
+		tools: ['fileTools'],
+		permissions,
+		defaultPermission: 'ask',
+		systemPrompt,
+		model: options.model,
+		local: options.local,
+		skills: extraSkills,
+		maxTokens: 2048,
+		autoLoadLucaSkill: true,
+	})
+
+	// ── UI setup ───────────────────────────────────────────────────────────
+	const ink = container.feature('ink', { enable: true })
+	await ink.loadModules()
+	const React = ink.React
+	const { Text } = ink.components
+	const inkModule = await import('ink')
+
+	let responseBuffer = ''
+	let inkInstance: any = null
+
+	function mdElement(content: string) {
+		const rendered = content ? String(ui.markdown(content)).trimEnd() : ''
+		return React.createElement(Text, null, rendered)
+	}
+
+	// Wire events on coder before starting (it forwards from inner assistant)
+	coder.on('chunk', (text: string) => {
+		responseBuffer += text
+		if (!inkInstance) {
+			process.stdout.write('\n')
+			inkInstance = inkModule.render(mdElement(responseBuffer), { patchConsole: false })
+		} else {
+			inkInstance.rerender(mdElement(responseBuffer))
+		}
+	})
+
+	coder.on('toolCall', (toolName: string, args: any) => {
+		if (inkInstance) { inkInstance.unmount(); inkInstance = null }
+		responseBuffer = ''
+		const argsStr = JSON.stringify(args).slice(0, 120)
+		process.stdout.write(colors.dim(`\n  ⟳ ${toolName}`) + colors.dim(`(${argsStr})\n`))
+	})
+
+	coder.on('toolResult', (toolName: string, result: any) => {
+		const preview = typeof result === 'string' ? result.slice(0, 100) : JSON.stringify(result).slice(0, 100)
+		process.stdout.write(colors.green(`  ✓ ${toolName}`) + colors.dim(` → ${preview}${preview.length >= 100 ? '…' : ''}\n`))
+	})
+
+	coder.on('toolError', (toolName: string, error: any) => {
+		const msg = error?.message || String(error)
+		process.stdout.write(colors.red(`  ✗ ${toolName}: ${msg}\n`))
+	})
+
+	coder.on('response', () => {
+		if (inkInstance) { inkInstance.unmount(); inkInstance = null }
+		responseBuffer = ''
+		process.stdout.write('\n')
+	})
+
+	// Start the coder (creates inner assistant, registers bash tool, stacks fileTools, loads skills)
+	await coder.start()
+
+	// ── Permission request handler ─────────────────────────────────────────
+	coder.on('permissionRequest', ({ id, toolName, args }: { id: string; toolName: string; args: Record<string, any> }) => {
+		if (inkInstance) { inkInstance.unmount(); inkInstance = null }
+
+		const argsPreview = Object.entries(args)
+			.map(([k, v]) => {
+				const val = typeof v === 'string'
+					? (v.length > 60 ? v.slice(0, 57) + '...' : v)
+					: JSON.stringify(v)
+				return `    ${colors.dim(k)}: ${val}`
+			})
+			.join('\n')
+
+		process.stdout.write('\n')
+		process.stdout.write(colors.yellow(`  ⚡ Permission required: ${colors.bold(toolName)}\n`))
+		if (argsPreview) process.stdout.write(argsPreview + '\n')
+		process.stdout.write(colors.dim(`\n  [y] approve  [n] deny  [a] allow all future ${toolName} calls\n`))
+
+		promptApproval(id, toolName)
+	})
+
+	coder.on('toolBlocked', (toolName: string, reason: string) => {
+		process.stdout.write(colors.red(`  ✗ ${toolName} blocked (${reason})\n`))
+	})
+
+	// ── Readline ───────────────────────────────────────────────────────────
+	let rl = readline.createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	})
+	let rlClosed = false
+	rl.on('close', () => { rlClosed = true })
+
+	function ensureRl() {
+		if (rlClosed) {
+			rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+			rlClosed = false
+			rl.on('close', () => { rlClosed = true })
+		}
+	}
+
+	function prompt(): Promise<string> {
+		return new Promise((resolve) => {
+			ensureRl()
+			rl.question(colors.cyan('\n  code > '), (answer: string) => resolve(answer.trim()))
+		})
+	}
+
+	function promptApproval(id: string, toolName: string) {
+		ensureRl()
+		rl.question(colors.yellow('  > '), (answer: string) => {
+			const a = answer.trim().toLowerCase()
+			if (a === 'y' || a === 'yes') {
+				coder.approve(id)
+			} else if (a === 'a' || a === 'always') {
+				coder.permitTool(toolName)
+				coder.approve(id)
+				process.stdout.write(colors.green(`  ✓ ${toolName} will be auto-approved from now on\n`))
+			} else {
+				coder.deny(id)
+			}
+		})
+	}
+
+	// ── Piped stdin mode ──────────────────────────────────────────────────
+	// When stdin is piped (e.g. `cat prompt.md | luca code`), read all of
+	// stdin as the initial prompt, run it, print the result, and exit.
+	if (!process.stdin.isTTY) {
+		const chunks: Buffer[] = []
+		for await (const chunk of process.stdin) {
+			chunks.push(chunk as Buffer)
+		}
+		const pipedInput = Buffer.concat(chunks).toString('utf-8').trim()
+
+		if (!pipedInput) {
+			console.error(colors.red('  No input received from stdin'))
+			process.exit(1)
+		}
+
+		console.log(colors.dim(`  Piped input: ${pipedInput.length} chars`))
+		await coder.ask(pipedInput)
+		process.exit(0)
+	}
+
+	// ── Banner ─────────────────────────────────────────────────────────────
+	console.log()
+	console.log(ui.banner('CODE', { font: 'Small', colors: ['cyan', 'blue'] }))
+
+	const toolCount = Object.keys(coder.tools).length
+	const allowCount = Object.values(permissions).filter(v => v === 'allow').length
+	const askCount = Object.values(permissions).filter(v => v === 'ask').length
+	const denyCount = Object.values(permissions).filter(v => v === 'deny').length
+	const loadedSkills = coder.state.get('loadedSkills') as string[]
+
+	console.log(colors.dim(`  ${toolCount} tools loaded`))
+	console.log(
+		colors.green(`  ${allowCount} allow`) + colors.dim(' · ') +
+		colors.yellow(`${askCount} ask`) + colors.dim(' · ') +
+		colors.red(`${denyCount} deny`)
+	)
+	if (loadedSkills.length) {
+		console.log(colors.dim(`  Skills: ${loadedSkills.join(', ')}`))
+	}
+	console.log()
+	console.log(colors.dim('  Commands: .exit  .perms  .skills  .allow <tool>  .deny <tool>  .gate <tool>  .allow-all  /console'))
+	console.log()
+
+	// ── Main loop ──────────────────────────────────────────────────────────
+	while (true) {
+		const input = await prompt()
+		if (!input) continue
+
+		// Meta commands
+		if (input === '.exit') break
+
+		if (input === '.perms') {
+			const perms = coder.permissions
+			const def = coder.state.get('defaultPermission')
+			console.log()
+			console.log(colors.dim(`  Default: ${def}`))
+			for (const [name, level] of Object.entries(perms).sort()) {
+				const color = level === 'allow' ? colors.green : level === 'deny' ? colors.red : colors.yellow
+				console.log(`  ${color(level.padEnd(5))} ${name}`)
+			}
+			console.log()
+			continue
+		}
+
+		if (input === '.skills') {
+			const skillsLib = container.feature('skillsLibrary')
+			if (!skillsLib.isStarted) await skillsLib.start()
+			const available = skillsLib.list()
+			const loaded = coder.state.get('loadedSkills') as string[]
+			console.log()
+			if (available.length === 0) {
+				console.log(colors.dim('  No skills found'))
+			} else {
+				for (const skill of available) {
+					const isLoaded = loaded.includes(skill.name)
+					const marker = isLoaded ? colors.green('●') : colors.dim('○')
+					console.log(`  ${marker} ${colors.bold(skill.name)} ${colors.dim('—')} ${colors.dim(skill.description || '')}`)
+				}
+				console.log()
+				console.log(colors.dim(`  ${loaded.length} loaded into context, ${available.length} total available`))
+			}
+			console.log()
+			continue
+		}
+
+		if (input.startsWith('.allow-all')) {
+			for (const t of Object.keys(coder.tools)) {
+				coder.permitTool(t)
+			}
+			console.log(colors.green('  All tools set to allow'))
+			continue
+		}
+
+		if (input.startsWith('.allow ')) {
+			const tool = input.slice(7).trim()
+			coder.permitTool(tool)
+			console.log(colors.green(`  ${tool} → allow`))
+			continue
+		}
+
+		if (input.startsWith('.deny ')) {
+			const tool = input.slice(6).trim()
+			coder.blockTool(tool)
+			console.log(colors.red(`  ${tool} → deny`))
+			continue
+		}
+
+		if (input.startsWith('.gate ')) {
+			const tool = input.slice(6).trim()
+			coder.gateTool(tool)
+			console.log(colors.yellow(`  ${tool} → ask`))
+			continue
+		}
+
+		if (input === '/console') {
+			// Pause readline so the REPL can own stdin
+			rl.close()
+
+			const featureContext: Record<string, any> = {}
+			for (const fname of container.features.available) {
+				try { featureContext[fname] = (container as any).feature(fname) } catch {}
+			}
+
+			const replPrompt = ui.colors.magenta('console') + ui.colors.dim(' > ')
+			const repl = container.feature('repl', { prompt: replPrompt })
+
+			console.log()
+			console.log(colors.dim('  Dropping into console. The coder is available as `coder`.'))
+			console.log(colors.dim('  Type .exit to return to code.'))
+			console.log()
+
+			await repl.start({
+				context: {
+					...featureContext,
+					coder,
+					console,
+					setTimeout, setInterval, clearTimeout, clearInterval,
+					fetch,
+				},
+			})
+
+			// Wait for the REPL to close
+			await new Promise<void>((resolve) => {
+				repl._rl!.on('close', resolve)
+			})
+
+			// Resume readline
+			console.log()
+			console.log(colors.dim('  Back in code mode.'))
+			rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+			rlClosed = false
+			rl.on('close', () => { rlClosed = true })
+			continue
+		}
+
+		// Ask the coder
+		await coder.ask(input)
+	}
+
+	rl.close()
+	console.log()
+}
+
+commands.registerHandler('code', {
+	description: 'Autonomous coding assistant with file tools, bash, and permission gating',
+	argsSchema,
+	handler: code,
+})

package/src/commands/console.ts

@@ -0,0 +1,189 @@
+import { z } from 'zod'
+import { commands } from '../command.js'
+import { CommandOptionsSchema } from '../schemas/base.js'
+import type { ContainerContext } from '../container.js'
+
+declare module '../command.js' {
+	interface AvailableCommands {
+		console: ReturnType<typeof commands.registerHandler>
+	}
+}
+
+export const argsSchema = CommandOptionsSchema.extend({
+	enable: z.string().optional().describe('Enable a feature before starting the REPL (e.g. --enable diskCache)'),
+	eval: z.string().optional().describe('Evaluate code, a script, or markdown file before dropping into the REPL'),
+})
+
+function resolveEvalTarget(ref: string, container: any): { type: 'code' | 'script' | 'markdown', value: string } {
+	const candidates = [ref, `${ref}.ts`, `${ref}.js`, `${ref}.md`]
+
+	for (const candidate of candidates) {
+		const resolved = container.paths.resolve(candidate)
+		if (container.fs.exists(resolved)) {
+			if (resolved.endsWith('.md')) return { type: 'markdown', value: resolved }
+			return { type: 'script', value: resolved }
+		}
+	}
+
+	// Not a file — treat as inline code
+	return { type: 'code', value: ref }
+}
+
+async function evalBeforeRepl(evalArg: string, container: any, featureContext: Record<string, any>): Promise<Record<string, any>> {
+	const target = resolveEvalTarget(evalArg, container)
+	const vm = container.feature('vm')
+	const ui = container.feature('ui')
+	const extraContext: Record<string, any> = {}
+
+	if (target.type === 'markdown') {
+		await container.docs.load()
+		const doc = await container.docs.parseMarkdownAtPath(target.value)
+		const transpiler = container.feature('transpiler')
+		const shared = vm.createContext({
+			console, fetch, URL, URLSearchParams,
+			setTimeout, clearTimeout, setInterval, clearInterval,
+			...featureContext,
+			...container.context,
+		})
+
+		const children = doc.ast.children
+		for (let i = 0; i < children.length; i++) {
+			const node = children[i]
+			if (node.type === 'code') {
+				const { value, lang, meta } = node
+				if (lang !== 'ts' && lang !== 'js' && lang !== 'tsx' && lang !== 'jsx') continue
+				if (meta && typeof meta === 'string' && meta.toLowerCase().includes('skip')) continue
+
+				console.log(ui.markdown(['```' + lang, value, '```'].join('\n')))
+
+				const needsTransform = lang === 'tsx' || lang === 'jsx'
+				let code = value
+				if (needsTransform) {
+					const { code: transformed } = transpiler.transformSync(value, { loader: lang as 'tsx' | 'jsx', format: 'cjs' })
+					code = transformed
+				}
+
+				await vm.run(code, shared)
+				Object.assign(shared, container.context)
+			} else {
+				const md = doc.stringify({ type: 'root', children: [node] })
+				console.log(ui.markdown(md))
+			}
+		}
+
+		Object.assign(extraContext, shared)
+	} else if (target.type === 'script') {
+		const code = container.fs.readFile(target.value, 'utf8')
+		const ctx = vm.createContext({
+			console, fetch, URL, URLSearchParams,
+			setTimeout, clearTimeout, setInterval, clearInterval,
+			...featureContext,
+			...container.context,
+		})
+		await vm.run(code, ctx)
+		Object.assign(extraContext, ctx)
+	} else {
+		const ctx = vm.createContext({
+			console, fetch, URL, URLSearchParams,
+			setTimeout, clearTimeout, setInterval, clearInterval,
+			...featureContext,
+			...container.context,
+		})
+		await vm.run(target.value, ctx)
+		Object.assign(extraContext, ctx)
+	}
+
+	return extraContext
+}
+
+export default async function lucaConsole(options: z.infer<typeof argsSchema>, context: ContainerContext) {
+	const container = context.container as any
+	const ui = container.feature('ui')
+
+	await container.helpers.discoverAll()
+
+	// make it easy to create features
+	container.addContext('feature', (...args: any) => container.feature(...args))
+
+	//this is a hack to make it so we can enable things before the console starts
+	if (container.argv.enable) {
+		for (const id of Array(container.argv.enable)) {
+			try {
+				container.feature(id, { ...container.argv, enable: true }).enable()
+			} catch(error: any) {
+				console.error(`Error enabling feature`, error.message)
+			}
+		}
+	}
+
+	const featureContext: Record<string, any> = {}
+	for (const name of container.features.available) {
+		try {
+			featureContext[name] = container.feature(name)
+		} catch {}
+	}
+
+	// Load user console module if present
+	const consoleModulePath = container.paths.resolve('luca.console.ts')
+	let consoleModuleLoaded = false
+	let consoleModuleError: Error | null = null
+
+	if (container.fs.exists(consoleModulePath)) {
+		try {
+			const vmFeature = container.feature('vm')
+			const userExports = vmFeature.loadModule(consoleModulePath, { container, console })
+			Object.assign(featureContext, userExports)
+			consoleModuleLoaded = true
+		} catch (err: any) {
+			consoleModuleError = err
+		}
+	}
+
+	// Run --eval target before starting the REPL
+	let evalContext: Record<string, any> = {}
+	if (options.eval) {
+		try {
+			evalContext = await evalBeforeRepl(options.eval, container, featureContext)
+		} catch (err: any) {
+			console.error(ui.colors.red(`  Error evaluating: ${err.message}`))
+		}
+	}
+
+	const prompt = ui.colors.cyan('luca') + ui.colors.dim(' > ')
+
+	console.log()
+	console.log(ui.colors.dim('  Luca REPL — all container features in scope. Tab to autocomplete.'))
+	if (options.eval) {
+		console.log(ui.colors.dim(`  Evaluated: ${options.eval}`))
+	}
+	if (consoleModuleLoaded) {
+		console.log(ui.colors.dim('  Loaded luca.console.ts exports into scope.'))
+	} else if (consoleModuleError) {
+		console.log(ui.colors.yellow('  ⚠ Failed to load luca.console.ts:'))
+		console.log(ui.colors.yellow(`    ${consoleModuleError.message}`))
+		console.log(ui.colors.dim('  The REPL will start without your custom exports.'))
+	}
+	console.log(ui.colors.dim('  Type .exit to quit.'))
+	console.log()
+
+	const repl = container.feature('repl', { prompt })
+	await repl.start({
+		context: {
+			...featureContext,
+			...evalContext,
+			console,
+			setTimeout,
+			setInterval,
+			clearTimeout,
+			clearInterval,
+			fetch,
+			Bun,
+		},
+	})
+}
+
+commands.registerHandler('console', {
+	description: 'Start an interactive REPL with all container features in scope',
+	argsSchema,
+	handler: lucaConsole,
+})