@soederpop/luca 0.0.25 → 0.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soederpop/luca",
-  "version": "0.0.25",
+  "version": "0.0.26",
   "website": "https://luca.soederpop.com",
   "description": "lightweight universal conversational architecture AKA Le Ultimate Component Architecture AKA Last Universal Common Ancestor, part AI part Human",
   "author": "jon soeder aka the people's champ <jon@soederpop.com>",

package/src/agi/features/assistant.ts

@@ -278,28 +278,30 @@ export class Assistant extends Feature<AssistantState, AssistantOptions> {
 	 *   .use(container.feature('git'))
 	 * ```
 	 */
-	use(fnOrHelper: ((assistant: this) => void | Promise<void>) | { toTools: () => { schemas: Record<string, z.ZodType>, handlers: Record<string, Function> } }): this {
+	use(fnOrHelper: ((assistant: this) => void | Promise<void>) | { toTools: () => { schemas: Record<string, z.ZodType>, handlers: Record<string, Function> } } | { schemas: Record<string, z.ZodType>, handlers: Record<string, Function> }): this {
 		if (typeof fnOrHelper === 'function') {
 			const result = fnOrHelper(this)
 			if (result && typeof (result as any).then === 'function') {
 				const pending = this.state.get('pendingPlugins') as Promise<void>[]
 				this.state.set('pendingPlugins', [...pending, result as Promise<void>])
 			}
-		} else if (fnOrHelper && typeof fnOrHelper.toTools === 'function') {
-			const { schemas, handlers } = fnOrHelper.toTools()
-			for (const name of Object.keys(schemas)) {
-				if(typeof handlers[name] === 'function') {
-					this.addTool(
-						name,
-						handlers[name] as any,
-						schemas[name],
-					)
-				}
-			}
+		} else if (fnOrHelper && typeof (fnOrHelper as any).toTools === 'function') {
+			this._registerTools((fnOrHelper as any).toTools())
+		} else if (fnOrHelper && 'schemas' in fnOrHelper && 'handlers' in fnOrHelper) {
+			this._registerTools(fnOrHelper as { schemas: Record<string, z.ZodType>, handlers: Record<string, Function> })
 		}
 		return this
 	}
 
+	/** Register tools from a `{ schemas, handlers }` object. */
+	private _registerTools({ schemas, handlers }: { schemas: Record<string, z.ZodType>, handlers: Record<string, Function> }) {
+		for (const name of Object.keys(schemas)) {
+			if (typeof handlers[name] === 'function') {
+				this.addTool(name, handlers[name] as any, schemas[name])
+			}
+		}
+	}
+
 	/**
 	 * Add a tool to this assistant. The tool name is derived from the
 	 * handler's function name.

package/src/agi/features/docs-reader.ts

@@ -108,15 +108,39 @@ export class DocsReader extends Feature<DocsReaderState, DocsReaderOptions> {
 
 	assistant?: Assistant
 
+
+	private generateSpecificCollectionExplainer() {
+		const { contentDb } = this
+		const fileTree = contentDb.fileTree
+		const modelDefinitionTable = contentDb.modelDefinitionTable
+		const modelNames = contentDb.modelNames
+		
+		const domainTermSummary = this.container.feature('ui').endent(`
+		## Domain Specific Terms 
+		
+		When the user is referring to one of the following nouns: ${modelNames.join(', ')} they are likely
+		referencing one of the documents defined by the following content models:
+
+		${Object.entries(modelDefinitionTable).map(([name, { description, glob, routePatterns }]) => `
+		- **${name}**: ${description}
+		Glob: ${glob}
+		Route Patterns: ${routePatterns.join(', ')}
+		`).join('\n')}
+		`)
+
+		return domainTermSummary
+	}
+
 	/** Start the docs reader by loading the contentDb and wiring its tools into an assistant. */
 	async start(): Promise<DocsReader> {
 		if (this.isStarted) return this
 
 		const contentDb = this.contentDb
 		if (!contentDb.isLoaded) await contentDb.load()
+			
 
 		this.assistant = this.container.feature('assistant', {
-			systemPrompt: CONTENT_DB_SYSTEM_PROMPT,
+			systemPrompt: [CONTENT_DB_SYSTEM_PROMPT, this.generateSpecificCollectionExplainer()].filter(Boolean).join('\n\n'),
 			model: this.options.model,
 			local: this.options.local,
 		}).use(contentDb)

package/src/bootstrap/generated.ts

@@ -1,5 +1,5 @@
 // Auto-generated bootstrap content
-// Generated at: 2026-03-22T06:53:18.884Z
+// Generated at: 2026-03-22T20:57:24.866Z
 // Source: docs/bootstrap/*.md, docs/bootstrap/templates/*, docs/examples/*.md, docs/tutorials/*.md
 //
 // Do not edit manually. Run: luca build-bootstrap

package/src/cli/build-info.ts

@@ -1,4 +1,4 @@
 // Generated at compile time — do not edit manually
-export const BUILD_SHA = '33ebc12'
+export const BUILD_SHA = '4f7677c'
 export const BUILD_BRANCH = 'main'
-export const BUILD_DATE = '2026-03-22T06:53:18Z'
+export const BUILD_DATE = '2026-03-22T20:57:24Z'

package/src/command.ts

@@ -266,6 +266,81 @@ export class CommandsRegistry extends Registry<Command<any>> {
 	override scope = 'commands'
 	override baseClass = Command as any
 
+	/**
+	 * Convert all registered commands into a `{ schemas, handlers }` object
+	 * compatible with `assistant.use()`.
+	 *
+	 * Each command becomes a tool whose parameters come from the command's
+	 * `argsSchema` (with internal CLI fields stripped) and whose handler
+	 * dispatches the command headlessly, returning `{ exitCode, stdout, stderr }`.
+	 *
+	 * @param container - The container used to instantiate and dispatch commands
+	 * @param options - Optional filter/transform options
+	 * @param options.include - Only include these command names (default: all)
+	 * @param options.exclude - Exclude these command names (default: none)
+	 * @param options.prefix - Prefix tool names (e.g. 'luca_' → 'luca_eval')
+	 */
+	toTools(
+		container: Container<any> & CommandsInterface,
+		options?: { include?: string[], exclude?: string[], prefix?: string },
+	): { schemas: Record<string, z.ZodType>, handlers: Record<string, Function> } {
+		const schemas: Record<string, z.ZodType> = {}
+		const handlers: Record<string, Function> = {}
+		const prefix = options?.prefix ?? ''
+		const includeSet = options?.include ? new Set(options.include) : null
+		const excludeSet = new Set(options?.exclude ?? [])
+
+		// Internal fields inherited from HelperOptionsSchema / CommandOptionsSchema
+		const internalFields = ['_', 'dispatchSource', 'name', '_cacheKey']
+
+		for (const name of this.available) {
+			if (excludeSet.has(name)) continue
+			if (includeSet && !includeSet.has(name)) continue
+
+			const Cmd = this.lookup(name) as typeof Command
+			const rawSchema = Cmd.argsSchema
+			const description = Cmd.commandDescription || Cmd.description || name
+
+			// Build a clean schema by stripping internal CLI fields from the argsSchema.
+			// If the schema is a ZodObject we can use .omit(), otherwise create a
+			// virtual passthrough schema so the tool still flows through.
+			let toolSchema: z.ZodType
+			try {
+				const shape = typeof (rawSchema as any)?._def?.shape === 'function'
+					? (rawSchema as any)._def.shape()
+					: (rawSchema as any)?._def?.shape
+
+				if (shape) {
+					// Build a new object schema omitting internal fields
+					const cleanShape: Record<string, z.ZodType> = {}
+					for (const [key, val] of Object.entries(shape)) {
+						if (internalFields.includes(key)) continue
+						cleanShape[key] = val as z.ZodType
+					}
+
+					toolSchema = Object.keys(cleanShape).length > 0
+						? z.object(cleanShape).describe(description)
+						: z.object({}).describe(description)
+				} else {
+					// Not a ZodObject — wrap as passthrough
+					toolSchema = z.object({}).describe(description)
+				}
+			} catch {
+				toolSchema = z.object({}).describe(description)
+			}
+
+			const toolName = `${prefix}${name}`
+			schemas[toolName] = toolSchema
+			handlers[toolName] = async (args: Record<string, any>) => {
+				const cmd = container.command(name as any)
+				const result = await cmd.dispatch(args ?? {}, 'headless')
+				return result ?? { exitCode: 0, stdout: '', stderr: '' }
+			}
+		}
+
+		return { schemas, handlers }
+	}
+
 	/**
 	 * Internal: register a command from a handler function.
 	 * Used by built-in commands. External commands should use the module export pattern.