@onmars/lunar-core 0.1.0

package/src/__tests__/plugin.test.ts

@@ -0,0 +1,258 @@
+/**
+ * # PluginRegistry — Functional Specification
+ *
+ * Central registry for all Lunar plugins: channels, agents, memory, TTS, STT.
+ *
+ * ## Design principles:
+ * - **Register → Get pattern**: register a plugin instance, retrieve it later by id.
+ * - **First-agent-wins default**: the first registered agent becomes the default
+ *   unless explicitly overridden with `registerAgent(agent, true)`.
+ * - **Strict uniqueness**: duplicate ids throw immediately (fail fast, not silently overwrite).
+ * - **Lifecycle management**: `initAll()` connects everything, `destroyAll()` tears down.
+ *   Individual failures in initAll don't block others (Promise.allSettled).
+ * - **Empty is valid**: empty registry works fine — no plugins means no-ops.
+ *
+ * ## Plugin types:
+ * | Type    | Register         | Get             | List            |
+ * |---------|------------------|-----------------|-----------------|
+ * | Channel | registerChannel  | getChannel(id)  | listChannels()  |
+ * | Agent   | registerAgent    | getAgent(id?)   | listAgents()    |
+ * | Memory  | registerMemory   | getMemory(id)   | listMemory()    |
+ */
+import { beforeEach, describe, expect, it } from 'bun:test'
+import { PluginRegistry } from '../lib/plugin'
+import type { Agent } from '../types/agent'
+import type { Channel } from '../types/channel'
+import type { MemoryProvider } from '../types/memory'
+
+// ─── Mock factories ────────────────────────────────────────────────
+
+function createMockChannel(id: string): Channel {
+  return {
+    id,
+    name: `Mock ${id}`,
+    connect: async () => {},
+    disconnect: async () => {},
+    isConnected: () => false,
+    send: async () => undefined,
+    sendTyping: async () => {},
+    onMessage: () => {},
+  }
+}
+
+function createMockAgent(id: string): Agent {
+  return {
+    id,
+    name: `Mock ${id}`,
+    init: async () => {},
+    destroy: async () => {},
+    query: async function* () {
+      yield { type: 'text' as const, content: 'test' }
+      yield { type: 'done' as const, sessionId: 'test-session' }
+    },
+    health: async () => ({ ok: true }),
+  }
+}
+
+function createMockMemory(id: string): MemoryProvider {
+  return {
+    id,
+    name: `Mock ${id}`,
+    init: async () => {},
+    destroy: async () => {},
+    recall: async () => [],
+    save: async () => {},
+    health: async () => ({ ok: true }),
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════
+
+describe('PluginRegistry', () => {
+  let registry: PluginRegistry
+
+  beforeEach(() => {
+    registry = new PluginRegistry()
+  })
+
+  // ─── Channel Registration ──────────────────────────────────────
+
+  describe('channels — platform adapters (Discord, Telegram, etc.)', () => {
+    it('registers and lists a channel by id', () => {
+      registry.registerChannel(createMockChannel('discord'))
+      expect(registry.listChannels()).toEqual(['discord'])
+    })
+
+    it('throws on duplicate channel id (fail-fast)', () => {
+      registry.registerChannel(createMockChannel('discord'))
+      expect(() => registry.registerChannel(createMockChannel('discord'))).toThrow(
+        "Channel 'discord' already registered",
+      )
+    })
+
+    it('supports multiple simultaneous channels', () => {
+      registry.registerChannel(createMockChannel('discord'))
+      registry.registerChannel(createMockChannel('telegram'))
+      expect(registry.listChannels()).toEqual(['discord', 'telegram'])
+    })
+  })
+
+  // ─── Agent Registration ────────────────────────────────────────
+
+  describe('agents — LLM backends (Claude, GPT, etc.)', () => {
+    it('registers and lists an agent', () => {
+      registry.registerAgent(createMockAgent('claude'))
+      expect(registry.listAgents()).toEqual(['claude'])
+    })
+
+    it('first registered agent becomes the default', () => {
+      registry.registerAgent(createMockAgent('claude'))
+      expect(registry.getAgent()!.id).toBe('claude')
+    })
+
+    it('explicit default=true overrides first-wins', () => {
+      registry.registerAgent(createMockAgent('gpt'))
+      registry.registerAgent(createMockAgent('claude'), true)
+      expect(registry.getAgent()!.id).toBe('claude')
+    })
+
+    it('throws on duplicate agent id (fail-fast)', () => {
+      registry.registerAgent(createMockAgent('claude'))
+      expect(() => registry.registerAgent(createMockAgent('claude'))).toThrow(
+        "Agent 'claude' already registered",
+      )
+    })
+
+    it('retrieves specific agent by id', () => {
+      registry.registerAgent(createMockAgent('claude'))
+      registry.registerAgent(createMockAgent('gpt'))
+
+      expect(registry.getAgent('gpt')!.id).toBe('gpt')
+      expect(registry.getAgent('claude')!.id).toBe('claude')
+    })
+
+    it('returns undefined for unknown agent id', () => {
+      expect(registry.getAgent('nonexistent')).toBeUndefined()
+    })
+  })
+
+  // ─── Memory Registration ───────────────────────────────────────
+
+  describe('memory — semantic memory backends (Brain, Mem0, etc.)', () => {
+    it('registers and retrieves memory provider', () => {
+      registry.registerMemory(createMockMemory('brain'))
+      expect(registry.getMemory('brain')!.id).toBe('brain')
+    })
+
+    it('returns undefined for unknown provider id', () => {
+      expect(registry.getMemory('nonexistent')).toBeUndefined()
+    })
+
+    it('supports multiple concurrent providers', () => {
+      registry.registerMemory(createMockMemory('brain'))
+      registry.registerMemory(createMockMemory('engram'))
+      expect(registry.listMemory()).toEqual(['brain', 'engram'])
+    })
+  })
+
+  // ─── Lifecycle ─────────────────────────────────────────────────
+
+  describe('lifecycle — initAll / destroyAll', () => {
+    it('initAll initializes channels, agents, and memory', async () => {
+      const inited = { channel: false, agent: false, memory: false }
+
+      const channel = createMockChannel('discord')
+      channel.connect = async () => {
+        inited.channel = true
+      }
+
+      const agent = createMockAgent('claude')
+      agent.init = async () => {
+        inited.agent = true
+      }
+
+      const memory = createMockMemory('brain')
+      memory.init = async () => {
+        inited.memory = true
+      }
+
+      registry.registerChannel(channel)
+      registry.registerAgent(agent)
+      registry.registerMemory(memory)
+
+      await registry.initAll()
+
+      expect(inited.channel).toBe(true)
+      expect(inited.agent).toBe(true)
+      expect(inited.memory).toBe(true)
+    })
+
+    it('initAll continues even when one plugin fails (resilient)', async () => {
+      const channel = createMockChannel('discord')
+      channel.connect = async () => {
+        throw new Error('Connect failed')
+      }
+
+      const agent = createMockAgent('claude')
+      let agentInited = false
+      agent.init = async () => {
+        agentInited = true
+      }
+
+      registry.registerChannel(channel)
+      registry.registerAgent(agent)
+
+      // Should NOT throw — uses Promise.allSettled internally
+      await registry.initAll()
+      expect(agentInited).toBe(true)
+    })
+
+    it('destroyAll tears down all plugins', async () => {
+      const destroyed = { channel: false, agent: false, memory: false }
+
+      const channel = createMockChannel('discord')
+      channel.disconnect = async () => {
+        destroyed.channel = true
+      }
+
+      const agent = createMockAgent('claude')
+      agent.destroy = async () => {
+        destroyed.agent = true
+      }
+
+      const memory = createMockMemory('brain')
+      memory.destroy = async () => {
+        destroyed.memory = true
+      }
+
+      registry.registerChannel(channel)
+      registry.registerAgent(agent)
+      registry.registerMemory(memory)
+
+      await registry.destroyAll()
+
+      expect(destroyed.channel).toBe(true)
+      expect(destroyed.agent).toBe(true)
+      expect(destroyed.memory).toBe(true)
+    })
+  })
+
+  // ─── Empty state ───────────────────────────────────────────────
+
+  describe('empty registry — valid zero-plugin state', () => {
+    it('all lists return empty arrays', () => {
+      expect(registry.listChannels()).toEqual([])
+      expect(registry.listAgents()).toEqual([])
+      expect(registry.listMemory()).toEqual([])
+    })
+
+    it('getAgent returns undefined (no default)', () => {
+      expect(registry.getAgent()).toBeUndefined()
+    })
+
+    it('lifecycle methods are no-ops on empty registry', async () => {
+      await registry.initAll()
+      await registry.destroyAll()
+    })
+  })
+})

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

@@ -0,0 +1,368 @@
+/**
+ * /remind Command — Test Suite
+ *
+ * Key contracts:
+ * - Parses relative time: "in 15m", "in 2h"
+ * - Parses absolute time: "14:30" (HH:MM today or tomorrow)
+ * - Parses ISO-8601: "2026-03-01T15:30", "2026-03-01T15:30Z"
+ * - Creates a one-shot scheduler job with kind: 'at'
+ * - Returns usage help when no args
+ * - Returns error when scheduler is not available
+ * - Returns error for invalid time formats
+ * - Uses channel persona name as channel, defaults to 'orbit'
+ */
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+import type { CommandContext } from '../lib/command-handler'
+import { remindCommand } from '../lib/commands/remind'
+import type { Job } from '../lib/scheduler'
+import { SessionTracker } from '../lib/session-tracker'
+
+// ═══════════════════════════════════════════════════════════
+// Mock store and scheduler
+// ═══════════════════════════════════════════════════════════
+
+function makeStore() {
+  return {
+    add: mock((_job: Job) => {}),
+    list: mock(() => []),
+    remove: mock(() => false),
+    get: mock(() => null),
+    enable: mock(() => {}),
+    disable: mock(() => {}),
+  }
+}
+
+function makeScheduler() {
+  const store = makeStore()
+  return {
+    scheduler: { getStore: () => store },
+    store,
+  }
+}
+
+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' },
+      text: '/remind',
+      timestamp: new Date(),
+    },
+    tracker: new SessionTracker(),
+    daemonStartedAt: Date.now(),
+    agent: { id: 'claude', name: 'Claude Code (CLI)' },
+    clearSession: async () => ({ sessionCleared: true, hooksRan: false }),
+    ...overrides,
+  }
+}
+
+// ═══════════════════════════════════════════════════════════
+// No scheduler
+// ═══════════════════════════════════════════════════════════
+
+describe('/remind — no scheduler', () => {
+  test('returns error when scheduler is not available', async () => {
+    const result = await remindCommand('in 15m test', makeCtx({ scheduler: undefined }))
+    expect(result).toContain('Scheduler is not enabled')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Usage / empty args
+// ═══════════════════════════════════════════════════════════
+
+describe('/remind usage', () => {
+  test('returns usage when no args', async () => {
+    const { scheduler } = makeScheduler()
+    const result = await remindCommand('', makeCtx({ scheduler: scheduler as any }))
+    expect(result).toContain('Usage')
+    expect(result).toContain('/remind')
+    expect(result).toContain('in 15m')
+    expect(result).toContain('in 2h')
+  })
+
+  test('returns usage when only whitespace', async () => {
+    const { scheduler } = makeScheduler()
+    const result = await remindCommand('   ', makeCtx({ scheduler: scheduler as any }))
+    expect(result).toContain('Usage')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Invalid format
+// ═══════════════════════════════════════════════════════════
+
+describe('/remind invalid format', () => {
+  test('rejects unparseable time format', async () => {
+    const { scheduler } = makeScheduler()
+    const result = await remindCommand(
+      'tomorrow Do something',
+      makeCtx({ scheduler: scheduler as any }),
+    )
+    expect(result).toContain('Invalid format')
+  })
+
+  test('rejects time without message', async () => {
+    const { scheduler } = makeScheduler()
+    const result = await remindCommand('in 15m', makeCtx({ scheduler: scheduler as any }))
+    expect(result).toContain('Invalid format')
+  })
+
+  test('rejects "in" without valid duration', async () => {
+    const { scheduler } = makeScheduler()
+    const result = await remindCommand('in abc Do thing', makeCtx({ scheduler: scheduler as any }))
+    expect(result).toContain('Invalid format')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Relative time: "in Xm" / "in Xh"
+// ═══════════════════════════════════════════════════════════
+
+describe('/remind relative time', () => {
+  test('parses "in 15m" and creates job', async () => {
+    const { scheduler, store } = makeScheduler()
+    const before = Date.now()
+    const result = await remindCommand(
+      'in 15m Turn off oven',
+      makeCtx({ scheduler: scheduler as any }),
+    )
+    const after = Date.now()
+
+    expect(result).toContain('Reminder set')
+    expect(store.add).toHaveBeenCalledTimes(1)
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    expect(job.schedule.kind).toBe('at')
+    expect(job.payload).toEqual({ kind: 'message', text: 'Turn off oven' })
+    expect(job.oneShot).toBe(true)
+    expect(job.enabled).toBe(true)
+
+    // Verify the scheduled time is ~15 minutes in the future
+    const atTime = new Date((job.schedule as any).at).getTime()
+    const expectedMin = before + 15 * 60_000
+    const expectedMax = after + 15 * 60_000
+    expect(atTime).toBeGreaterThanOrEqual(expectedMin - 100)
+    expect(atTime).toBeLessThanOrEqual(expectedMax + 100)
+  })
+
+  test('parses "in 2h" and creates job', async () => {
+    const { scheduler, store } = makeScheduler()
+    const before = Date.now()
+    const result = await remindCommand(
+      'in 2h Check email',
+      makeCtx({ scheduler: scheduler as any }),
+    )
+    const after = Date.now()
+
+    expect(result).toContain('Reminder set')
+    expect(store.add).toHaveBeenCalledTimes(1)
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    const atTime = new Date((job.schedule as any).at).getTime()
+    const expectedMin = before + 2 * 3600_000
+    const expectedMax = after + 2 * 3600_000
+    expect(atTime).toBeGreaterThanOrEqual(expectedMin - 100)
+    expect(atTime).toBeLessThanOrEqual(expectedMax + 100)
+  })
+
+  test('parses "in 1m" for short durations', async () => {
+    const { scheduler, store } = makeScheduler()
+    const before = Date.now()
+    await remindCommand('in 1m Quick task', makeCtx({ scheduler: scheduler as any }))
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    const atTime = new Date((job.schedule as any).at).getTime()
+    expect(atTime).toBeGreaterThanOrEqual(before + 60_000 - 100)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Absolute time: HH:MM
+// ═══════════════════════════════════════════════════════════
+
+describe('/remind absolute time HH:MM', () => {
+  test('parses "14:30" format and creates job', async () => {
+    const { scheduler, store } = makeScheduler()
+    const result = await remindCommand(
+      '14:30 Daily summary',
+      makeCtx({ scheduler: scheduler as any }),
+    )
+
+    expect(result).toContain('Reminder set')
+    expect(store.add).toHaveBeenCalledTimes(1)
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    expect(job.schedule.kind).toBe('at')
+    expect(job.payload).toEqual({ kind: 'message', text: 'Daily summary' })
+    expect(job.oneShot).toBe(true)
+
+    // The scheduled time should have hours=14, minutes=30
+    const atTime = new Date((job.schedule as any).at)
+    // Either today or tomorrow depending on current time
+    expect(atTime.getHours()).toBe(14)
+    expect(atTime.getMinutes()).toBe(30)
+  })
+
+  test('parses "09:00" with leading zero', async () => {
+    const { scheduler, store } = makeScheduler()
+    await remindCommand('09:00 Morning standup', makeCtx({ scheduler: scheduler as any }))
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    const atTime = new Date((job.schedule as any).at)
+    expect(atTime.getHours()).toBe(9)
+    expect(atTime.getMinutes()).toBe(0)
+  })
+
+  test('if time already passed today, schedules for tomorrow', async () => {
+    const { scheduler, store } = makeScheduler()
+    // Use 00:01 which has almost certainly already passed (test runs during the day)
+    await remindCommand('00:01 Midnight check', makeCtx({ scheduler: scheduler as any }))
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    const atTime = new Date((job.schedule as any).at)
+    // Should be in the future
+    expect(atTime.getTime()).toBeGreaterThan(Date.now())
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// ISO-8601 time
+// ═══════════════════════════════════════════════════════════
+
+describe('/remind ISO-8601 time', () => {
+  test('parses ISO-8601 date without timezone', async () => {
+    const { scheduler, store } = makeScheduler()
+    const result = await remindCommand(
+      '2026-12-25T10:00 Christmas check',
+      makeCtx({ scheduler: scheduler as any }),
+    )
+
+    expect(result).toContain('Reminder set')
+    expect(store.add).toHaveBeenCalledTimes(1)
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    expect(job.schedule.kind).toBe('at')
+    const atTime = new Date((job.schedule as any).at)
+    expect(atTime.getFullYear()).toBe(2026)
+    expect(atTime.getMonth()).toBe(11) // December = 11
+    expect(atTime.getDate()).toBe(25)
+  })
+
+  test('parses ISO-8601 date with Z timezone', async () => {
+    const { scheduler, store } = makeScheduler()
+    const result = await remindCommand(
+      '2026-06-15T08:30Z Morning meeting',
+      makeCtx({ scheduler: scheduler as any }),
+    )
+
+    expect(result).toContain('Reminder set')
+    const job = (store.add as any).mock.calls[0][0] as Job
+    const atTime = new Date((job.schedule as any).at)
+    expect(atTime.getUTCHours()).toBe(8)
+    expect(atTime.getUTCMinutes()).toBe(30)
+  })
+
+  test('parses ISO-8601 date with offset timezone', async () => {
+    const { scheduler, store } = makeScheduler()
+    const result = await remindCommand(
+      '2026-06-15T08:30+05:00 Meeting',
+      makeCtx({ scheduler: scheduler as any }),
+    )
+
+    expect(result).toContain('Reminder set')
+    const job = (store.add as any).mock.calls[0][0] as Job
+    const atTime = new Date((job.schedule as any).at)
+    // 08:30+05:00 = 03:30 UTC
+    expect(atTime.getUTCHours()).toBe(3)
+    expect(atTime.getUTCMinutes()).toBe(30)
+  })
+
+  test('parses ISO-8601 with seconds', async () => {
+    const { scheduler, store } = makeScheduler()
+    const result = await remindCommand(
+      '2026-06-15T08:30:45Z Precise time',
+      makeCtx({ scheduler: scheduler as any }),
+    )
+
+    expect(result).toContain('Reminder set')
+    const job = (store.add as any).mock.calls[0][0] as Job
+    const atTime = new Date((job.schedule as any).at)
+    expect(atTime.getUTCSeconds()).toBe(45)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Job structure
+// ═══════════════════════════════════════════════════════════
+
+describe('/remind job structure', () => {
+  test('uses channel persona name when available', async () => {
+    const { scheduler, store } = makeScheduler()
+    await remindCommand(
+      'in 10m Test',
+      makeCtx({
+        scheduler: scheduler as any,
+        channelPersona: { name: 'research' } as any,
+      }),
+    )
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    expect(job.channel).toBe('research')
+  })
+
+  test('defaults channel to "orbit" when no persona', async () => {
+    const { scheduler, store } = makeScheduler()
+    await remindCommand(
+      'in 10m Test',
+      makeCtx({
+        scheduler: scheduler as any,
+        channelPersona: undefined,
+      }),
+    )
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    expect(job.channel).toBe('orbit')
+  })
+
+  test('job is marked oneShot', async () => {
+    const { scheduler, store } = makeScheduler()
+    await remindCommand('in 5m Check', makeCtx({ scheduler: scheduler as any }))
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    expect(job.oneShot).toBe(true)
+  })
+
+  test('job has valid UUID id', async () => {
+    const { scheduler, store } = makeScheduler()
+    await remindCommand('in 5m Check', makeCtx({ scheduler: scheduler as any }))
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    // UUID format: 8-4-4-4-12
+    expect(job.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/)
+  })
+
+  test('job schedule is ISO string', async () => {
+    const { scheduler, store } = makeScheduler()
+    await remindCommand('in 5m Check', makeCtx({ scheduler: scheduler as any }))
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    const at = (job.schedule as any).at
+    expect(typeof at).toBe('string')
+    // Should be a valid ISO date string
+    expect(new Date(at).toISOString()).toBe(at)
+  })
+
+  test('message text is trimmed', async () => {
+    const { scheduler, store } = makeScheduler()
+    await remindCommand('in 5m   Some spaced message  ', makeCtx({ scheduler: scheduler as any }))
+
+    const job = (store.add as any).mock.calls[0][0] as Job
+    const text = (job.payload as any).text
+    // Should be trimmed
+    expect(text).not.toMatch(/^\s/)
+    expect(text).not.toMatch(/\s$/)
+  })
+})