@soederpop/luca 0.0.6 → 0.0.8

package/src/introspection/generated.web.ts

@@ -1,7 +1,7 @@
 import { setBuildTimeData, setContainerBuildTimeData } from './index.js';
 
 // Auto-generated introspection registry data
-// Generated at: 2026-03-12T02:48:58.250Z
+// Generated at: 2026-03-19T00:28:05.997Z
 
 setBuildTimeData('features.containerLink', {
   "id": "features.containerLink",

package/src/introspection/index.ts

@@ -161,12 +161,38 @@ export function getContainerBuildTimeData(className: string): Partial<ContainerI
 export function setBuildTimeData(key: string, data: HelperIntrospection) {
 	const existing = __INTROSPECTION__.get(key)
 
+	// Merge events: build-time AST provides descriptions, runtime Zod schemas provide arguments.
+	// For each event, preserve runtime arguments if the build-time entry has none.
+	const mergedEvents: Record<string, any> = { ...(data.events || {}) }
+	if (existing?.events) {
+		for (const [eventName, existingEvent] of Object.entries(existing.events)) {
+			if (mergedEvents[eventName]) {
+				// Build-time entry exists — merge in runtime arguments and description if build-time has none
+				const buildArgs = mergedEvents[eventName].arguments || {}
+				const runtimeArgs = (existingEvent as any).arguments || {}
+				const buildDesc = mergedEvents[eventName].description || ''
+				const runtimeDesc = (existingEvent as any).description || ''
+				const isGenericDesc = buildDesc.startsWith('Event emitted by ')
+				if (Object.keys(buildArgs).length === 0 && Object.keys(runtimeArgs).length > 0) {
+					mergedEvents[eventName] = { ...mergedEvents[eventName], arguments: runtimeArgs }
+				}
+				if (isGenericDesc && runtimeDesc) {
+					mergedEvents[eventName] = { ...mergedEvents[eventName], description: runtimeDesc }
+				}
+			} else {
+				// Event only exists in runtime (from Zod schema) — preserve it
+				mergedEvents[eventName] = existingEvent
+			}
+		}
+	}
+
 	__INTROSPECTION__.set(key, {
 		...data,
 		// preserve runtime-derived className/state/options if registration already happened
 		className: data.className || existing?.className,
 		state: existing?.state || data.state || {},
 		options: existing?.options || data.options || {},
+		events: mergedEvents,
 		getters: data.getters || existing?.getters || {},
 		envVars: existing?.envVars || data.envVars || [],
 		examples: data.examples || existing?.examples,

package/src/node/container.ts

@@ -6,12 +6,16 @@ import type { FeatureOptions } from "./feature";
 import { features, Feature } from "./feature";
 import type { AvailableFeatures } from "../feature";
 import { Client, type ClientsInterface } from "../client";
+import "../clients/rest";
+import "../clients/graph";
+import "../clients/websocket";
 import { Server, type ServersInterface } from "../server";
 import "../servers/express";
 import "../servers/socket";
 import "../servers/mcp";
 import { Command, type CommandsInterface } from "../command";
 import { Endpoint, type EndpointsInterface } from "../endpoint";
+import { Selector, type SelectorsInterface } from "../selector";
 
 import minimist from "minimist";
 import { omit, kebabCase, camelCase, mapKeys, castArray } from "lodash-es";
@@ -53,7 +57,6 @@ import "./features/google-sheets";
 import "./features/google-calendar";
 import "./features/google-docs";
 import "./features/window-manager";
-import "./features/launcher-app-command-listener";
 import "./features/nlp";
 import "./features/process-manager"
 import "./features/tts";
@@ -98,7 +101,6 @@ import type { GoogleSheets } from './features/google-sheets';
 import type { GoogleCalendar } from './features/google-calendar';
 import type { GoogleDocs } from './features/google-docs';
 import type { WindowManager } from './features/window-manager';
-import type { LauncherAppCommandListener } from './features/launcher-app-command-listener';
 import type { NLP } from './features/nlp';
 import type { ProcessManager } from './features/process-manager'
 import type { TTS } from './features/tts';
@@ -138,7 +140,6 @@ export {
   type GoogleCalendar,
   type GoogleDocs,
   type WindowManager,
-  type LauncherAppCommandListener,
   type NLP,
   type ProcessManager,
   type TTS,
@@ -204,7 +205,6 @@ export interface NodeFeatures extends AvailableFeatures {
   googleCalendar: typeof GoogleCalendar;
   googleDocs: typeof GoogleDocs;
   windowManager: typeof WindowManager;
-  launcherAppCommandListener: typeof LauncherAppCommandListener;
   nlp: typeof NLP;
   processManager: typeof ProcessManager;
   tts: typeof TTS;
@@ -214,7 +214,7 @@ export interface NodeFeatures extends AvailableFeatures {
   dns: typeof Dns;
 }
 
-export type ClientsAndServersInterface = ClientsInterface & ServersInterface & CommandsInterface & EndpointsInterface;
+export type ClientsAndServersInterface = ClientsInterface & ServersInterface & CommandsInterface & EndpointsInterface & SelectorsInterface;
 
 export interface NodeContainer extends ClientsAndServersInterface {}
 
@@ -253,7 +253,6 @@ export class NodeContainer<
   googleCalendar?: GoogleCalendar;
   googleDocs?: GoogleDocs;
   windowManager?: WindowManager;
-  launcherAppCommandListener?: LauncherAppCommandListener;
   nlp?: NLP;
   processManager?: ProcessManager;
   tts?: TTS;
@@ -286,7 +285,7 @@ export class NodeContainer<
       }
     });
 
-    this.use(Client).use(Server).use(Command).use(Endpoint);
+    this.use(Client).use(Server).use(Command).use(Endpoint).use(Selector);
   }
 
   override get Feature() {

package/src/node/features/content-db.ts

@@ -1,7 +1,8 @@
 import { Feature } from '../feature.js'
+import * as contentbaseExports from 'contentbase'
 import { parse, Collection, extractSections, type ModelDefinition } from 'contentbase'
 import { z } from 'zod'
-import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
+import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import { join, dirname } from 'node:path'
 import { existsSync, readdirSync } from 'node:fs'
 
@@ -18,6 +19,10 @@ export const ContentDbOptionsSchema = FeatureOptionsSchema.extend({
 export type ContentDbState = z.infer<typeof ContentDbStateSchema>
 export type ContentDbOptions = z.infer<typeof ContentDbOptionsSchema>
 
+export const ContentDbEventsSchema = FeatureEventsSchema.extend({
+  reloaded: z.tuple([]).describe('When the content collection is reloaded from disk'),
+}).describe('ContentDb events')
+
 /**
  * Provides access to a Contentbase Collection for a folder of structured markdown files.
  *
@@ -37,6 +42,7 @@ export class ContentDb extends Feature<ContentDbState, ContentDbOptions> {
   static override shortcut = 'features.contentDb' as const
   static override stateSchema = ContentDbStateSchema
   static override optionsSchema = ContentDbOptionsSchema
+  static override eventsSchema = ContentDbEventsSchema
   static { Feature.register(this, 'contentDb') }
 
   override get initialState(): ContentDbState {
@@ -52,11 +58,52 @@ export class ContentDb extends Feature<ContentDbState, ContentDbOptions> {
   }
 
   _collection?: Collection
+  private _contentbaseSeeded = false
 
   /** Returns the lazily-initialized Collection instance for the configured rootPath. */
   get collection() {
     if (this._collection) return this._collection
-    return this._collection = new Collection({ rootPath: this.options.rootPath })
+
+    const opts: any = { rootPath: this.options.rootPath }
+
+    // When contentbase isn't in node_modules (e.g. compiled luca binary),
+    // provide a VM-based module loader so models.ts can resolve its imports
+    if (!this._canNativeImportContentbase()) {
+      opts.moduleLoader = (filePath: string) => {
+        this._seedContentbaseVirtualModules()
+        const vm = this.container.feature('vm') as any
+        return vm.loadModule(filePath)
+      }
+    }
+
+    return this._collection = new Collection(opts)
+  }
+
+  /** Check if contentbase is resolvable via native import from the project root */
+  private _canNativeImportContentbase(): boolean {
+    const cwd = this.container.cwd
+    return existsSync(join(cwd, 'node_modules', 'contentbase'))
+  }
+
+  /** Seed the VM with virtual modules so models.ts can import from 'contentbase', 'zod', etc. */
+  private _seedContentbaseVirtualModules(): void {
+    if (this._contentbaseSeeded) return
+    this._contentbaseSeeded = true
+
+    const vm = this.container.feature('vm') as any
+
+    // Seed luca modules first (helpers does this for @soederpop/luca)
+    const helpers = this.container.feature('helpers') as any
+    if (helpers?.seedVirtualModules) {
+      helpers.seedVirtualModules()
+    }
+
+    // Register contentbase barrel — everything the library exports
+    vm.defineModule('contentbase', contentbaseExports)
+
+    // Common deps that models.ts files tend to use
+    try { vm.defineModule('js-yaml', require('js-yaml')) } catch {}
+    try { vm.defineModule('mdast-util-to-string', require('mdast-util-to-string')) } catch {}
   }
 
   /** Returns the absolute resolved path to the collection root directory. */

package/src/node/features/disk-cache.ts

@@ -36,15 +36,17 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
   static override optionsSchema = DiskCacheOptionsSchema
   static { Feature.register(this, 'diskCache') }
 
-  constructor(options: DiskCacheOptions, context: ContainerContext) {
-    super(options, context)
-    this._cache = this.create() 
-    this.hide('_cache')
-  }
-  
   /** Returns the underlying cacache instance configured with the cache directory path. */
   get cache() {
-    return this._cache
+    if(this._cache) { 
+	    return this._cache
+    }
+
+    const cache = this.create()
+
+    Object.defineProperty(this, '_cache', { value: cache, enumerable: false })
+
+    return cache
   }
   
   /**
@@ -328,7 +330,7 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
  
   /**
    * Create a cacache instance with the specified path
-   * @param path - Optional cache directory path (defaults to options.path or node_modules/.cache/luca-disk-cache)
+   * @param path - Optional cache directory path (defaults to options.path or ~/.cache/luca/disk-cache-{cwdHash})
    * @returns Configured cacache instance with all methods bound to the path
    * @example
    * ```typescript
@@ -336,7 +338,12 @@ export class DiskCache extends Feature<FeatureState,DiskCacheOptions> {
    * ```
    */
   create(path?: string) {
-    path = path || this.options.path || this.container.paths.resolve('node_modules', '.cache', 'luca-disk-cache')
+    if (!path && !this.options.path) {
+      const cwdHash = this.container.utils.hashObject(this.container.cwd)
+      path = this.container.paths.resolve(process.env.HOME!, '.cache', 'luca', `disk-cache-${cwdHash}`)
+    } else {
+      path = path || this.options.path!
+    }
     this.container.fs.ensureFolder(path)
     const arg = (fn: (...args: any) => any) => partial(fn, path);
 

package/src/node/features/dns.ts

@@ -131,10 +131,23 @@ export class Dns extends Feature<DnsState, DnsOptions> {
     }
   }
 
+  private _resolvedDigPath: string | null = null
+
   get proc() {
     return this.container.feature('proc')
   }
 
+  /** Resolved path to the dig binary */
+  get digPath(): string {
+    if (this._resolvedDigPath) return this._resolvedDigPath
+    try {
+      this._resolvedDigPath = this.proc.exec('which dig').trim()
+    } catch {
+      this._resolvedDigPath = 'dig'
+    }
+    return this._resolvedDigPath
+  }
+
   /**
    * Checks whether the `dig` binary is available on the system.
    *
@@ -148,7 +161,7 @@ export class Dns extends Feature<DnsState, DnsOptions> {
    * ```
    */
   async isAvailable(): Promise<boolean> {
-    const result = await this.proc.spawnAndCapture('dig', ['-v'])
+    const result = await this.proc.spawnAndCapture(this.digPath, ['-v'])
     // dig -v prints version to stderr and exits 0
     return result.exitCode === 0
   }
@@ -180,7 +193,7 @@ export class Dns extends Feature<DnsState, DnsOptions> {
    */
   async resolve(domain: string, type: DnsRecordType, options: QueryOptions = {}): Promise<DnsQueryResult> {
     const args = this.buildDigArgs(domain, type, options)
-    const result = await this.proc.spawnAndCapture('dig', args)
+    const result = await this.proc.spawnAndCapture(this.digPath, args)
 
     if (result.exitCode !== 0) {
       throw new Error(`dig query failed: ${result.stderr || 'unknown error'}`)
@@ -446,7 +459,7 @@ export class Dns extends Feature<DnsState, DnsOptions> {
     }
     args.unshift('-x', ip)
 
-    const result = await this.proc.spawnAndCapture('dig', args)
+    const result = await this.proc.spawnAndCapture(this.digPath, args)
 
     if (result.exitCode !== 0) {
       throw new Error(`dig reverse lookup failed: ${result.stderr || 'unknown error'}`)

package/src/node/features/docker.ts

@@ -101,10 +101,24 @@ export class Docker extends Feature<DockerState, DockerOptions> {
   /**
    * Get the proc feature for executing shell commands
    */
+  private _resolvedDockerPath: string | null = null
+
   get proc() {
     return this.container.feature('proc')
   }
 
+  /** Resolve the docker binary path via `which`, caching the result. Options take precedence. */
+  get dockerPath(): string {
+    if (this.options.dockerPath) return this.options.dockerPath
+    if (this._resolvedDockerPath) return this._resolvedDockerPath
+    try {
+      this._resolvedDockerPath = this.proc.exec('which docker').trim()
+    } catch {
+      this._resolvedDockerPath = 'docker'
+    }
+    return this._resolvedDockerPath
+  }
+
   /**
    * Check if Docker is available and working.
    *
@@ -117,8 +131,7 @@ export class Docker extends Feature<DockerState, DockerOptions> {
    */
   async checkDockerAvailability(): Promise<boolean> {
     try {
-      const dockerPath = this.options.dockerPath || 'docker'
-      const result = await this.proc.spawnAndCapture(dockerPath, ['--version'])
+      const result = await this.proc.spawnAndCapture(this.dockerPath, ['--version'])
       
       if (result.exitCode === 0) {
         this.setState({ isDockerAvailable: true, lastError: undefined })
@@ -152,8 +165,7 @@ export class Docker extends Feature<DockerState, DockerOptions> {
     }
 
     try {
-      const dockerPath = this.options.dockerPath || 'docker'
-      const result = await this.proc.spawnAndCapture(dockerPath, args)
+      const result = await this.proc.spawnAndCapture(this.dockerPath, args)
       
       if (result.exitCode !== 0) {
         this.setState({ lastError: result.stderr })

package/src/node/features/esbuild.ts

@@ -31,7 +31,7 @@ export class ESBuild extends Feature {
     return esbuild.transformSync(code, {
       loader: 'ts',
       format: 'esm',
-      target: 'es2020',
+      target: 'esnext',
       sourcemap: false,
       minify: false,
       ...options
@@ -48,12 +48,32 @@ export class ESBuild extends Feature {
     return esbuild.transform(code, {
       loader: 'ts',
       format: 'esm',
-      target: 'es2020',
+      target: 'esnext',
       sourcemap: false,
       minify: false,
       ...options
     })
   }
+
+  /**
+   * Bundle one or more entry points, resolving imports and requires into a single output.
+   * Supports Node platform by default so require() and Node builtins are handled.
+   * Returns in-memory output files unless write is enabled in options.
+   * @param entryPoints - File paths to bundle from
+   * @param options - esbuild BuildOptions overrides
+   * @returns The build result with outputFiles when write is false
+   */
+  async bundle(entryPoints: string[], options?: esbuild.BuildOptions) {
+    return esbuild.build({
+      entryPoints,
+      bundle: true,
+      platform: 'node',
+      format: 'esm',
+      target: 'esnext',
+      write: false,
+      ...options
+    })
+  }
 }
 
 export default ESBuild