@onmars/lunar-core 0.1.0

package/src/lib/moon-loader.ts

@@ -0,0 +1,291 @@
+import { existsSync, readdirSync, statSync } from 'node:fs'
+import { basename, resolve } from 'node:path'
+import type { ChannelPersona, Moon } from '../types/moon'
+import { log } from './logger'
+import type { SkillLoader } from './skill-loader'
+
+/**
+ * MoonLoader — Discovers, loads, and manages Moon personalities.
+ *
+ * Conventions:
+ * - Default moon: workspace root (SOUL.md, AGENTS.md, IDENTITY.md)
+ * - Additional moons: `moons/<name>/` subdirectories
+ * - Minimum requirement: SOUL.md must exist
+ * - `moons` config section only needed for custom paths
+ *
+ * Usage:
+ *   const loader = new MoonLoader()
+ *   await loader.loadAll('~/.lunar')
+ *   const moon = loader.resolve(channelPersona)
+ *   const prompt = loader.buildSystemPrompt(moon, channelPersona)
+ */
+export class MoonLoader {
+  private moons = new Map<string, Moon>()
+  private defaultMoonName = ''
+  private skillManifest = ''
+  private skillLoader?: SkillLoader
+
+  /** Get number of loaded moons */
+  get size(): number {
+    return this.moons.size
+  }
+
+  /** Set the skills manifest to inject into system prompts */
+  setSkillManifest(manifest: string): void {
+    this.skillManifest = manifest
+  }
+
+  /** Set the full SkillLoader for per-channel skill filtering */
+  setSkillLoader(loader: SkillLoader): void {
+    this.skillLoader = loader
+    this.skillManifest = loader.getManifest() // backward compat fallback
+  }
+
+  /**
+   * Load all moons from workspace.
+   *
+   * 1. Root workspace → default moon
+   * 2. `moons/` subdirectories → additional moons (auto-discovered)
+   * 3. `moonsConfig` overrides → custom paths for specific moons
+   *
+   * @param workspacePath — root workspace directory
+   * @param moonsConfig — optional name→path mapping for custom moon locations
+   */
+  /**
+   * Moon config entry for loadAll.
+   * Includes path + optional model/context1m overrides.
+   */
+  async loadAll(
+    workspacePath: string,
+    moonsConfig?: Record<string, string | { path: string; model?: string; context1m?: boolean }>,
+    defaultMoonOverrides?: { model?: string; context1m?: boolean },
+  ): Promise<void> {
+    this.moons.clear()
+    this.defaultMoonName = ''
+
+    // 1. Load root moon (default)
+    const rootSoul = resolve(workspacePath, 'SOUL.md')
+    if (existsSync(rootSoul)) {
+      const rootMoon = await this.loadFromPath(workspacePath, undefined, defaultMoonOverrides)
+      this.moons.set(rootMoon.name, rootMoon)
+      this.defaultMoonName = rootMoon.name
+      log.info(
+        { name: rootMoon.name, path: workspacePath, model: rootMoon.model ?? '(default)' },
+        'Default moon loaded',
+      )
+    } else {
+      log.warn({ path: workspacePath }, 'No SOUL.md in workspace root — no default moon')
+    }
+
+    // 2. Auto-discover moons in moons/ directory
+    const moonsDir = resolve(workspacePath, 'moons')
+    if (existsSync(moonsDir) && statSync(moonsDir).isDirectory()) {
+      for (const entry of readdirSync(moonsDir)) {
+        const moonPath = resolve(moonsDir, entry)
+        if (!statSync(moonPath).isDirectory()) continue
+        if (!existsSync(resolve(moonPath, 'SOUL.md'))) continue
+
+        // Skip if already loaded via moonsConfig (config takes precedence)
+        if (moonsConfig?.[entry]) continue
+
+        const moon = await this.loadFromPath(moonPath, entry)
+        this.moons.set(entry, moon)
+        log.info({ name: entry, path: moonPath }, 'Moon auto-discovered')
+      }
+    }
+
+    // 3. Load explicitly configured moons (override auto-discovered)
+    if (moonsConfig) {
+      for (const [name, value] of Object.entries(moonsConfig)) {
+        const moonPath = typeof value === 'string' ? value : value.path
+        const overrides =
+          typeof value === 'object' ? { model: value.model, context1m: value.context1m } : undefined
+        const fullPath = resolve(workspacePath, moonPath)
+
+        if (!existsSync(resolve(fullPath, 'SOUL.md'))) {
+          log.warn({ name, path: fullPath }, 'Configured moon has no SOUL.md — skipping')
+          continue
+        }
+
+        const moon = await this.loadFromPath(fullPath, name, overrides)
+        this.moons.set(name, moon)
+        log.info(
+          { name, path: fullPath, model: moon.model ?? '(default)' },
+          'Moon loaded from config',
+        )
+      }
+    }
+
+    log.info(
+      { total: this.moons.size, default: this.defaultMoonName, names: [...this.moons.keys()] },
+      'All moons loaded',
+    )
+  }
+
+  /**
+   * Load a single moon from a directory path.
+   * Backward-compatible: can be used standalone for single-moon setups.
+   */
+  async load(workspacePath: string): Promise<Moon> {
+    const moon = await this.loadFromPath(workspacePath)
+    this.moons.set(moon.name, moon)
+    if (!this.defaultMoonName) this.defaultMoonName = moon.name
+    return moon
+  }
+
+  /** Get a loaded moon by name */
+  get(name: string): Moon | undefined {
+    return this.moons.get(name)
+  }
+
+  /** Get the default (root) moon */
+  getDefault(): Moon | undefined {
+    return this.defaultMoonName ? this.moons.get(this.defaultMoonName) : undefined
+  }
+
+  /** List all loaded moon names */
+  list(): string[] {
+    return [...this.moons.keys()]
+  }
+
+  /**
+   * Resolve which moon should handle a channel.
+   *
+   * Priority:
+   * 1. ChannelPersona.moon → look up by name
+   * 2. No moon specified → use default (root) moon
+   * 3. Not found → undefined (caller should handle gracefully)
+   */
+  resolve(channel?: ChannelPersona): Moon | undefined {
+    if (!channel?.moon) return this.getDefault()
+
+    const moon = this.moons.get(channel.moon)
+    if (!moon) {
+      log.warn(
+        { requested: channel.moon, channel: channel.name, available: this.list() },
+        'Moon not found for channel — falling back to default',
+      )
+      return this.getDefault()
+    }
+    return moon
+  }
+
+  /**
+   * Build the complete system prompt for a channel.
+   *
+   * Structure:
+   *   # Moon: <name>
+   *   ## SOUL.md — personality core
+   *   ## AGENTS.md — operational rules
+   *   ## IDENTITY.md — identity metadata
+   *   ## Workspace — available files
+   *   ## Channel: <name> — per-channel overlay (if present)
+   */
+  buildSystemPrompt(moon: Moon, channel?: ChannelPersona): string {
+    const sections: string[] = []
+
+    // Header
+    sections.push(`# Moon: ${moon.name}`)
+
+    // Soul (personality core — always first)
+    if (moon.soul.trim()) {
+      sections.push(`## SOUL.md\n${moon.soul.trim()}`)
+    }
+
+    // Agents (operational rules)
+    if (moon.agents.trim()) {
+      sections.push(`## AGENTS.md\n${moon.agents.trim()}`)
+    }
+
+    // Identity
+    if (moon.identity.trim()) {
+      sections.push(`## IDENTITY.md\n${moon.identity.trim()}`)
+    }
+
+    // Workspace reference
+    const workspaceLines = [
+      '## Workspace',
+      `Your workspace is: ${moon.path}`,
+      '',
+      'Files available on-demand (read with tools when needed):',
+      '- `USER.md` — Information about the user',
+      '- `MEMORY.md` — Persistent context and decisions',
+      '- `memory/` — Session notes and daily logs',
+    ]
+    sections.push(workspaceLines.join('\n'))
+
+    // Skills manifest — per-channel filter if SkillLoader available, else global manifest
+    const manifest = this.skillLoader
+      ? this.skillLoader.getManifest(channel?.skills)
+      : this.skillManifest
+    if (manifest) {
+      sections.push(manifest.trim())
+    }
+    // Channel persona overlay
+    if (channel) {
+      const channelLines = [`## Channel: #${channel.name}`]
+      if (channel.tone) channelLines.push(`- **Tone:** ${channel.tone}`)
+      if (channel.focus) channelLines.push(`- **Focus:** ${channel.focus}`)
+      if (channel.instructions) {
+        channelLines.push('')
+        channelLines.push(channel.instructions)
+      }
+      sections.push(channelLines.join('\n'))
+    }
+
+    return sections.join('\n\n---\n\n')
+  }
+
+  /**
+   * Find a ChannelPersona by Discord channel ID from a list of channel configs.
+   * Returns undefined if no matching channel is configured (open routing).
+   */
+  findChannel(discordChannelId: string, channels: ChannelPersona[]): ChannelPersona | undefined {
+    return channels.find((c) => c.id === discordChannelId)
+  }
+
+  // --- Private ---
+
+  private async loadFromPath(
+    moonPath: string,
+    nameOverride?: string,
+    overrides?: { model?: string; context1m?: boolean },
+  ): Promise<Moon> {
+    const soulPath = resolve(moonPath, 'SOUL.md')
+    const agentsPath = resolve(moonPath, 'AGENTS.md')
+    const identityPath = resolve(moonPath, 'IDENTITY.md')
+
+    if (!existsSync(soulPath)) {
+      throw new Error(`Missing required SOUL.md at ${soulPath}`)
+    }
+
+    const soul = await Bun.file(soulPath).text()
+    const agents = existsSync(agentsPath) ? await Bun.file(agentsPath).text() : ''
+    const identity = existsSync(identityPath) ? await Bun.file(identityPath).text() : ''
+
+    if (!soul.trim()) {
+      log.warn({ path: soulPath }, 'SOUL.md exists but is empty — moon will have no personality')
+    }
+
+    // Display name: prefer IDENTITY.md, fall back to nameOverride or dir name
+    const name = this.parseName(identity, moonPath) || (nameOverride ?? basename(moonPath))
+
+    return {
+      name,
+      soul,
+      agents,
+      identity,
+      path: moonPath,
+      model: overrides?.model,
+      context1m: overrides?.context1m,
+    }
+  }
+
+  private parseName(identity: string, moonPath: string): string {
+    const nameMatch = identity.match(/\*\*Name:\*\*\s*(.+)/i)
+    if (nameMatch?.[1]) {
+      return nameMatch[1].trim()
+    }
+    return basename(moonPath)
+  }
+}

package/src/lib/plugin.ts

@@ -0,0 +1,148 @@
+import type { Agent } from '../types/agent'
+import type { Channel } from '../types/channel'
+import type { MemoryProvider } from '../types/memory'
+import type { STTProvider, TTSProvider } from '../types/voice'
+import { log } from './logger'
+
+/**
+ * Plugin registry — the central hub that connects all adapters.
+ *
+ * Register channels, agents, memory providers, and voice providers here.
+ * The router uses the registry to dispatch messages.
+ */
+export class PluginRegistry {
+  private channels = new Map<string, Channel>()
+  private agents = new Map<string, Agent>()
+  private memoryProviders = new Map<string, MemoryProvider>()
+  private ttsProviders = new Map<string, TTSProvider>()
+  private sttProviders = new Map<string, STTProvider>()
+
+  private defaultAgentId?: string
+
+  // --- Registration ---
+
+  registerChannel(channel: Channel): void {
+    if (this.channels.has(channel.id)) {
+      throw new Error(`Channel '${channel.id}' already registered`)
+    }
+    this.channels.set(channel.id, channel)
+    log.info({ channel: channel.id }, 'Channel registered')
+  }
+
+  registerAgent(agent: Agent, isDefault = false): void {
+    if (this.agents.has(agent.id)) {
+      throw new Error(`Agent '${agent.id}' already registered`)
+    }
+    this.agents.set(agent.id, agent)
+    if (isDefault || !this.defaultAgentId) {
+      this.defaultAgentId = agent.id
+    }
+    log.info({ agent: agent.id, default: isDefault }, 'Agent registered')
+  }
+
+  registerMemory(provider: MemoryProvider): void {
+    this.memoryProviders.set(provider.id, provider)
+    log.info({ memory: provider.id }, 'Memory provider registered')
+  }
+
+  registerTTS(provider: TTSProvider): void {
+    this.ttsProviders.set(provider.id, provider)
+    log.info({ tts: provider.id }, 'TTS provider registered')
+  }
+
+  registerSTT(provider: STTProvider): void {
+    this.sttProviders.set(provider.id, provider)
+    log.info({ stt: provider.id }, 'STT provider registered')
+  }
+
+  // --- Retrieval ---
+
+  getChannel(id: string): Channel | undefined {
+    return this.channels.get(id)
+  }
+
+  getAgent(id?: string): Agent | undefined {
+    if (id) return this.agents.get(id)
+    if (this.defaultAgentId) return this.agents.get(this.defaultAgentId)
+    return undefined
+  }
+
+  getMemory(id: string): MemoryProvider | undefined {
+    return this.memoryProviders.get(id)
+  }
+
+  getTTS(id?: string): TTSProvider | undefined {
+    if (id) return this.ttsProviders.get(id)
+    // Return first available
+    const [first] = this.ttsProviders.values()
+    return first
+  }
+
+  getSTT(id?: string): STTProvider | undefined {
+    if (id) return this.sttProviders.get(id)
+    const [first] = this.sttProviders.values()
+    return first
+  }
+
+  // --- Lifecycle ---
+
+  /** Initialize all registered plugins */
+  async initAll(): Promise<void> {
+    const inits: Promise<void>[] = []
+
+    for (const agent of this.agents.values()) {
+      inits.push(
+        agent.init().catch((e) => log.error({ agent: agent.id, err: e }, 'Agent init failed')),
+      )
+    }
+    for (const channel of this.channels.values()) {
+      inits.push(
+        channel
+          .connect()
+          .catch((e) => log.error({ channel: channel.id, err: e }, 'Channel connect failed')),
+      )
+    }
+    for (const mem of this.memoryProviders.values()) {
+      inits.push(
+        mem.init().catch((e) => log.error({ memory: mem.id, err: e }, 'Memory init failed')),
+      )
+    }
+    for (const tts of this.ttsProviders.values()) {
+      inits.push(tts.init().catch((e) => log.error({ tts: tts.id, err: e }, 'TTS init failed')))
+    }
+    for (const stt of this.sttProviders.values()) {
+      inits.push(stt.init().catch((e) => log.error({ stt: stt.id, err: e }, 'STT init failed')))
+    }
+
+    await Promise.allSettled(inits)
+    log.info('All plugins initialized')
+  }
+
+  /** Gracefully destroy all plugins */
+  async destroyAll(): Promise<void> {
+    const destroys: Promise<void>[] = []
+
+    for (const channel of this.channels.values()) destroys.push(channel.disconnect())
+    for (const agent of this.agents.values()) destroys.push(agent.destroy())
+    for (const mem of this.memoryProviders.values()) destroys.push(mem.destroy())
+    for (const tts of this.ttsProviders.values()) destroys.push(tts.destroy())
+    for (const stt of this.sttProviders.values()) destroys.push(stt.destroy())
+
+    await Promise.allSettled(destroys)
+    log.info('All plugins destroyed')
+  }
+
+  // --- Inspection ---
+
+  listChannels(): string[] {
+    return [...this.channels.keys()]
+  }
+
+  listAgents(): string[] {
+    return [...this.agents.keys()]
+  }
+
+  listMemory(): string[] {
+    return [...this.memoryProviders.keys()]
+  }
+}