@onmars/lunar-core 0.1.0

package/src/__tests__/moon-loader.test.ts

@@ -0,0 +1,398 @@
+/**
+ * # MoonLoader — Functional Specification
+ *
+ * Loads "moons" — persona configurations from the workspace filesystem.
+ * Each moon is a directory with SOUL.md, AGENTS.md (optional), IDENTITY.md (optional).
+ *
+ * ## Core concepts:
+ * - **Moon**: a persona (name, soul prompt, agents prompt, identity metadata)
+ * - **Root moon**: loaded from workspace root (SOUL.md at top level) — becomes default
+ * - **Auto-discovery**: scans `moons/` subdirectory for additional personas
+ * - **Config override**: `moonsConfig` map (name → path) takes precedence over auto-discovery
+ *
+ * ## Key behaviors:
+ * - `loadAll(workspace)` → loads root moon + discovers moons/ + applies config overrides
+ * - `resolve(channel?)` → returns the moon for a channel, or the default
+ * - `buildSystemPrompt(moon, channel?)` → assembles the full system prompt from parts
+ * - `findChannel(id)` → reverse lookup: Discord channel ID → ChannelPersona
+ * - Display name comes from IDENTITY.md `**Name:**` field, not directory name
+ */
+
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { join, resolve } from 'node:path'
+import { MoonLoader } from '../lib/moon-loader'
+import { SkillLoader } from '../lib/skill-loader'
+import type { ChannelPersona } from '../types/moon'
+
+const FIXTURES = resolve(import.meta.dir, 'fixtures')
+
+describe('MoonLoader', () => {
+  let loader: MoonLoader
+
+  beforeEach(() => {
+    loader = new MoonLoader()
+  })
+
+  describe('load (single moon, backward compat)', () => {
+    it('loads a moon from workspace root', async () => {
+      const moon = await loader.load(FIXTURES)
+
+      expect(moon.name).toBe('Deimos')
+      expect(moon.soul).toContain('I am Deimos')
+      expect(moon.agents).toContain('Be concise')
+      expect(moon.identity).toContain('🌑')
+      expect(moon.path).toBe(FIXTURES)
+    })
+
+    it('sets loaded moon as default', async () => {
+      await loader.load(FIXTURES)
+
+      const def = loader.getDefault()
+      expect(def).toBeDefined()
+      expect(def!.name).toBe('Deimos')
+    })
+  })
+
+  describe('loadAll', () => {
+    it('loads root moon as default', async () => {
+      await loader.loadAll(FIXTURES)
+
+      expect(loader.size).toBeGreaterThanOrEqual(1)
+      const def = loader.getDefault()
+      expect(def).toBeDefined()
+      expect(def!.name).toBe('Deimos')
+    })
+
+    it('auto-discovers moons in moons/ directory', async () => {
+      await loader.loadAll(FIXTURES)
+
+      const athena = loader.get('athena')
+      expect(athena).toBeDefined()
+      expect(athena!.name).toBe('Athena')
+      expect(athena!.soul).toContain('study tutor')
+    })
+
+    it('loads all moons (root + auto-discovered)', async () => {
+      await loader.loadAll(FIXTURES)
+      expect(loader.size).toBe(3) // root + athena + hermes
+    })
+
+    it('lists all moon names', async () => {
+      await loader.loadAll(FIXTURES)
+
+      const names = loader.list()
+      expect(names).toContain('Deimos')
+      expect(names).toContain('athena')
+      expect(names).toContain('hermes')
+    })
+
+    // ── Phase D: Agent Workspaces ──────────────────────────────
+
+    it('auto-discovers moon in moons/hermes/ when SOUL.md exists', async () => {
+      await loader.loadAll(FIXTURES)
+
+      const hermes = loader.get('hermes')
+      expect(hermes).toBeDefined()
+      expect(hermes!.soul).toContain('Hermes')
+      expect(hermes!.path).toBe(resolve(FIXTURES, 'moons/hermes'))
+    })
+
+    it('parses moon name from IDENTITY.md **Name:** line', async () => {
+      await loader.loadAll(FIXTURES)
+
+      // athena fixture has IDENTITY.md with "**Name:** Athena"
+      const athena = loader.get('athena')
+      expect(athena).toBeDefined()
+      expect(athena!.name).toBe('Athena') // parsed from IDENTITY.md, not directory name
+    })
+
+    it('falls back to directory name when IDENTITY.md is absent', async () => {
+      await loader.loadAll(FIXTURES)
+
+      // hermes fixture has SOUL.md but NO IDENTITY.md
+      const hermes = loader.get('hermes')
+      expect(hermes).toBeDefined()
+      expect(hermes!.name).toBe('hermes') // directory name, not parsed from IDENTITY.md
+    })
+
+    it('uses explicit moonsConfig paths', async () => {
+      await loader.loadAll(FIXTURES, {
+        'custom-athena': 'moons/athena',
+      })
+
+      // auto-discovered 'athena' should be skipped (config takes precedence)
+      expect(loader.get('custom-athena')).toBeDefined()
+      expect(loader.get('custom-athena')!.soul).toContain('Athena')
+    })
+
+    it('passes model and context1m to configured moons', async () => {
+      await loader.loadAll(FIXTURES, {
+        'athena-1m': { path: 'moons/athena', model: 'opus', context1m: true },
+      })
+
+      const moon = loader.get('athena-1m')
+      expect(moon).toBeDefined()
+      expect(moon!.model).toBe('opus')
+      expect(moon!.context1m).toBe(true)
+    })
+
+    it('moon without model config has undefined model', async () => {
+      await loader.loadAll(FIXTURES, {
+        'plain-athena': 'moons/athena',
+      })
+
+      const moon = loader.get('plain-athena')
+      expect(moon).toBeDefined()
+      expect(moon!.model).toBeUndefined()
+      expect(moon!.context1m).toBeUndefined()
+    })
+
+    it('default moon receives overrides', async () => {
+      await loader.loadAll(FIXTURES, {}, { model: 'sonnet', context1m: true })
+
+      const defaultMoon = loader.getDefault()
+      expect(defaultMoon).toBeDefined()
+      expect(defaultMoon!.model).toBe('sonnet')
+      expect(defaultMoon!.context1m).toBe(true)
+    })
+
+    it('default moon without overrides has no model', async () => {
+      await loader.loadAll(FIXTURES)
+
+      const defaultMoon = loader.getDefault()
+      expect(defaultMoon).toBeDefined()
+      expect(defaultMoon!.model).toBeUndefined()
+    })
+
+    it('mixed string and object configs work together', async () => {
+      await loader.loadAll(FIXTURES, {
+        'string-moon': 'moons/athena',
+        'object-moon': { path: 'moons/athena', model: 'opus' },
+      })
+
+      const stringMoon = loader.get('string-moon')
+      const objectMoon = loader.get('object-moon')
+      expect(stringMoon!.model).toBeUndefined()
+      expect(objectMoon!.model).toBe('opus')
+    })
+  })
+
+  describe('resolve', () => {
+    beforeEach(async () => {
+      await loader.loadAll(FIXTURES)
+    })
+
+    it('returns default moon when no channel specified', () => {
+      const moon = loader.resolve()
+      expect(moon).toBeDefined()
+      expect(moon!.name).toBe('Deimos')
+    })
+
+    it('returns default moon when channel has no moon field', () => {
+      const channel: ChannelPersona = { id: '123', name: 'orbit', platform: 'discord' }
+      const moon = loader.resolve(channel)
+      expect(moon!.name).toBe('Deimos')
+    })
+
+    it('returns specific moon when channel references it', () => {
+      const channel: ChannelPersona = {
+        id: '456',
+        name: 'study',
+        platform: 'discord',
+        moon: 'athena',
+      }
+      const moon = loader.resolve(channel)
+      expect(moon).toBeDefined()
+      expect(moon!.name).toBe('Athena')
+    })
+
+    it('falls back to default when referenced moon not found', () => {
+      const channel: ChannelPersona = {
+        id: '789',
+        name: 'unknown',
+        platform: 'discord',
+        moon: 'nonexistent',
+      }
+      const moon = loader.resolve(channel)
+      expect(moon!.name).toBe('Deimos')
+    })
+  })
+
+  describe('buildSystemPrompt', () => {
+    beforeEach(async () => {
+      await loader.loadAll(FIXTURES)
+    })
+
+    it('includes moon name in header', () => {
+      const moon = loader.getDefault()!
+      const prompt = loader.buildSystemPrompt(moon)
+      expect(prompt).toContain('# Moon: Deimos')
+    })
+
+    it('includes SOUL.md content', () => {
+      const moon = loader.getDefault()!
+      const prompt = loader.buildSystemPrompt(moon)
+      expect(prompt).toContain('## SOUL.md')
+      expect(prompt).toContain('I am Deimos')
+    })
+
+    it('includes AGENTS.md content', () => {
+      const moon = loader.getDefault()!
+      const prompt = loader.buildSystemPrompt(moon)
+      expect(prompt).toContain('## AGENTS.md')
+      expect(prompt).toContain('Be concise')
+    })
+
+    it('includes workspace reference', () => {
+      const moon = loader.getDefault()!
+      const prompt = loader.buildSystemPrompt(moon)
+      expect(prompt).toContain('## Workspace')
+      expect(prompt).toContain('USER.md')
+      expect(prompt).toContain('MEMORY.md')
+    })
+
+    it('includes channel persona when provided', () => {
+      const moon = loader.getDefault()!
+      const channel: ChannelPersona = {
+        id: '123',
+        name: 'research',
+        platform: 'discord',
+        tone: 'Curious, thorough',
+        focus: 'Deep analysis',
+        instructions: 'No length limits when the topic deserves it.',
+      }
+      const prompt = loader.buildSystemPrompt(moon, channel)
+
+      expect(prompt).toContain('## Channel: #research')
+      expect(prompt).toContain('**Tone:** Curious, thorough')
+      expect(prompt).toContain('**Focus:** Deep analysis')
+      expect(prompt).toContain('No length limits')
+    })
+
+    it('omits channel section when no channel provided', () => {
+      const moon = loader.getDefault()!
+      const prompt = loader.buildSystemPrompt(moon)
+      expect(prompt).not.toContain('## Channel:')
+    })
+
+    it('builds different prompts for different moons', () => {
+      const deimos = loader.get('Deimos')!
+      const athena = loader.get('athena')!
+
+      const p1 = loader.buildSystemPrompt(deimos)
+      const p2 = loader.buildSystemPrompt(athena)
+
+      expect(p1).toContain('I am Deimos')
+      expect(p1).not.toContain('study tutor')
+
+      expect(p2).toContain('study tutor')
+      expect(p2).not.toContain('I am Deimos')
+    })
+  })
+
+  describe('findChannel', () => {
+    const channels: ChannelPersona[] = [
+      { id: '111', name: 'orbit', platform: 'discord', moon: 'lunar', tone: 'Direct' },
+      { id: '222', name: 'research', platform: 'discord', tone: 'Curious' },
+      { id: '333', name: 'athena', platform: 'telegram', moon: 'athena' },
+    ]
+
+    it('finds channel by Discord ID', () => {
+      const ch = loader.findChannel('222', channels)
+      expect(ch).toBeDefined()
+      expect(ch!.name).toBe('research')
+    })
+
+    it('returns undefined for unknown channel ID', () => {
+      const ch = loader.findChannel('999', channels)
+      expect(ch).toBeUndefined()
+    })
+  })
+
+  // ─── Per-channel skill filtering via setSkillLoader ──────────
+
+  describe('setSkillLoader + per-channel skill filtering', () => {
+    const skillFixtures = join(import.meta.dir, 'fixtures', 'skills')
+
+    it('setSkillLoader stores loader and sets skillManifest for backward compat', async () => {
+      await loader.loadAll(FIXTURES)
+      const skillLoader = new SkillLoader()
+      await skillLoader.scan([skillFixtures])
+
+      loader.setSkillLoader(skillLoader)
+
+      // buildSystemPrompt without channel should include all skills
+      const moon = loader.getDefault()!
+      const prompt = loader.buildSystemPrompt(moon)
+      expect(prompt).toContain('## Skills')
+      expect(prompt).toContain('brain')
+      expect(prompt).toContain('notion')
+    })
+
+    it('filters skills when channel has skills allowlist', async () => {
+      await loader.loadAll(FIXTURES)
+      const skillLoader = new SkillLoader()
+      await skillLoader.scan([skillFixtures])
+      loader.setSkillLoader(skillLoader)
+
+      const moon = loader.getDefault()!
+      const channel: ChannelPersona = {
+        id: '123',
+        name: 'dev',
+        platform: 'discord',
+        skills: ['brain'],
+      }
+
+      const prompt = loader.buildSystemPrompt(moon, channel)
+      expect(prompt).toContain('brain')
+      expect(prompt).not.toContain('notion')
+    })
+
+    it('includes all skills when channel has no skills array', async () => {
+      await loader.loadAll(FIXTURES)
+      const skillLoader = new SkillLoader()
+      await skillLoader.scan([skillFixtures])
+      loader.setSkillLoader(skillLoader)
+
+      const moon = loader.getDefault()!
+      const channel: ChannelPersona = {
+        id: '456',
+        name: 'orbit',
+        platform: 'discord',
+      }
+
+      const prompt = loader.buildSystemPrompt(moon, channel)
+      expect(prompt).toContain('## Skills')
+      expect(prompt).toContain('brain')
+      expect(prompt).toContain('notion')
+    })
+
+    it('omits skills section when channel has empty skills array', async () => {
+      await loader.loadAll(FIXTURES)
+      const skillLoader = new SkillLoader()
+      await skillLoader.scan([skillFixtures])
+      loader.setSkillLoader(skillLoader)
+
+      const moon = loader.getDefault()!
+      const channel: ChannelPersona = {
+        id: '789',
+        name: 'notifications',
+        platform: 'discord',
+        skills: [],
+      }
+
+      const prompt = loader.buildSystemPrompt(moon, channel)
+      expect(prompt).not.toContain('## Skills')
+    })
+
+    it('falls back to skillManifest string when no skillLoader is set', async () => {
+      await loader.loadAll(FIXTURES)
+      loader.setSkillManifest('## Skills\n\n- **custom** — Custom skill\n')
+
+      const moon = loader.getDefault()!
+      const prompt = loader.buildSystemPrompt(moon)
+      expect(prompt).toContain('## Skills')
+      expect(prompt).toContain('custom')
+    })
+  })
+})

package/src/__tests__/ping-command.test.ts

@@ -0,0 +1,85 @@
+/**
+ * /ping Command — Test Suite
+ *
+ * Spec: quick latency check and daemon uptime.
+ *
+ * Key contracts:
+ * - Always returns "Pong!"
+ * - Shows latency when message timestamp is recent (< 60s)
+ * - Omits latency when timestamp is too old (>= 60s)
+ * - Shows uptime when daemonStartedAt > 0
+ * - Omits uptime when daemonStartedAt is 0
+ */
+import { describe, expect, test } from 'bun:test'
+import type { CommandContext } from '../lib/command-handler'
+import { pingCommand } from '../lib/commands/ping'
+import { SessionTracker } from '../lib/session-tracker'
+
+function makeCtx(overrides?: Partial<CommandContext>): CommandContext {
+  return {
+    sessionKey: 'test:channel-1',
+    message: {
+      id: 'msg-1',
+      channelId: 'channel-1',
+      sender: { id: 'user-1', name: 'Test User', username: 'testuser' },
+      text: '/ping',
+      timestamp: new Date(),
+    },
+    tracker: new SessionTracker(),
+    daemonStartedAt: Date.now(),
+    agent: { id: 'claude', name: 'Claude Code (CLI)' },
+    clearSession: async () => ({ sessionCleared: true, hooksRan: false }),
+    ...overrides,
+  }
+}
+
+// ═══════════════════════════════════════════════════════════
+// Basic response
+// ═══════════════════════════════════════════════════════════
+
+describe('/ping basic', () => {
+  test('always returns "Pong!"', () => {
+    const result = pingCommand('', makeCtx())
+    expect(result).toContain('**Pong!**')
+  })
+
+  test('shows latency in ms with a recent timestamp', () => {
+    const result = pingCommand('', makeCtx())
+    expect(result).toMatch(/Latency: \d+ms/)
+  })
+
+  test('omits latency when timestamp is too old (> 60s)', () => {
+    const ctx = makeCtx({
+      message: {
+        id: 'msg-1',
+        channelId: 'channel-1',
+        sender: { id: 'user-1', name: 'Test User' },
+        text: '/ping',
+        timestamp: new Date(Date.now() - 120_000), // 2 minutes ago
+      },
+    })
+    const result = pingCommand('', ctx)
+    expect(result).not.toContain('Latency:')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Uptime
+// ═══════════════════════════════════════════════════════════
+
+describe('/ping uptime', () => {
+  test('shows uptime when daemonStartedAt > 0', () => {
+    const ctx = makeCtx({
+      daemonStartedAt: Date.now() - 3_600_000, // 1 hour ago
+    })
+    const result = pingCommand('', ctx)
+    expect(result).toContain('Uptime:')
+    expect(result).toContain('1h')
+  })
+
+  test('omits uptime when daemonStartedAt is 0', () => {
+    const ctx = makeCtx({ daemonStartedAt: 0 })
+    const result = pingCommand('', ctx)
+    expect(result).not.toContain('Uptime:')
+  })
+})