@onmars/lunar-core 0.1.0

package/src/__tests__/model-catalog.test.ts

@@ -0,0 +1,215 @@
+/**
+ * Model Catalog — Test Suite
+ *
+ * Spec: provides model metadata (context window, pricing, display names)
+ * for any model ID, with graceful fallback for unknown models.
+ *
+ * Key contracts:
+ * - Exact match by model ID
+ * - Normalized match (strip date suffix)
+ * - Prefix match (partial model names)
+ * - Unknown models get sensible defaults
+ * - Cost calculation is accurate per pricing
+ */
+import { describe, expect, test } from 'bun:test'
+import {
+  calculateCost,
+  getContextWindowSize,
+  getModelDisplayName,
+  getModelInfo,
+  listModels,
+} from '../lib/model-catalog'
+
+// ═══════════════════════════════════════════════════════════
+// Model lookup
+// ═══════════════════════════════════════════════════════════
+
+describe('getModelInfo', () => {
+  test('exact match returns correct info', () => {
+    const info = getModelInfo('claude-sonnet-4-6')
+    expect(info.displayName).toBe('Claude Sonnet 4.6')
+    expect(info.contextWindow).toBe(200_000)
+    expect(info.inputPricePerM).toBe(3.0)
+  })
+
+  test('date suffix is stripped for matching', () => {
+    const info = getModelInfo('claude-sonnet-4-5-20250514')
+    expect(info.displayName).toBe('Claude Sonnet 4.5')
+    expect(info.contextWindow).toBe(200_000)
+  })
+
+  test('another date suffix variant', () => {
+    const info = getModelInfo('claude-opus-4-6-20260301')
+    expect(info.displayName).toBe('Claude Opus 4.6')
+    expect(info.maxOutput).toBe(32_768)
+  })
+
+  test('prefix match for extended model IDs', () => {
+    const info = getModelInfo('claude-haiku-4-5-something-extra')
+    // Should match 'claude-haiku-4-5' prefix
+    expect(info.displayName).toBe('Claude Haiku 4.5')
+  })
+
+  test('unknown model returns defaults with model ID as name', () => {
+    const info = getModelInfo('gpt-5-turbo')
+    expect(info.displayName).toBe('gpt-5-turbo')
+    expect(info.contextWindow).toBe(200_000) // safe default
+  })
+
+  test('opus models have higher pricing', () => {
+    const sonnet = getModelInfo('claude-sonnet-4-6')
+    const opus = getModelInfo('claude-opus-4-6')
+    expect(opus.inputPricePerM).toBeGreaterThan(sonnet.inputPricePerM)
+    expect(opus.outputPricePerM).toBeGreaterThan(sonnet.outputPricePerM)
+  })
+
+  test('haiku models have lower pricing', () => {
+    const sonnet = getModelInfo('claude-sonnet-4-6')
+    const haiku = getModelInfo('claude-haiku-4-5')
+    expect(haiku.inputPricePerM).toBeLessThan(sonnet.inputPricePerM)
+    expect(haiku.outputPricePerM).toBeLessThan(sonnet.outputPricePerM)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Convenience accessors
+// ═══════════════════════════════════════════════════════════
+
+describe('getModelDisplayName', () => {
+  test('returns human-readable name', () => {
+    expect(getModelDisplayName('claude-sonnet-4-6')).toBe('Claude Sonnet 4.6')
+  })
+
+  test('returns model ID for unknown models', () => {
+    expect(getModelDisplayName('mystery-model')).toBe('mystery-model')
+  })
+})
+
+describe('getContextWindowSize', () => {
+  test('returns context window for known model', () => {
+    expect(getContextWindowSize('claude-opus-4-6')).toBe(200_000)
+  })
+
+  test('returns default 200K for unknown model', () => {
+    expect(getContextWindowSize('unknown-model')).toBe(200_000)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Cost calculation
+// ═══════════════════════════════════════════════════════════
+
+describe('calculateCost', () => {
+  test('basic input/output cost for Sonnet', () => {
+    // Sonnet: $3/M input, $15/M output
+    const cost = calculateCost('claude-sonnet-4-6', {
+      inputTokens: 1_000_000,
+      outputTokens: 1_000_000,
+    })
+    expect(cost).toBeCloseTo(18.0, 2) // $3 + $15
+  })
+
+  test('cost with cache tokens', () => {
+    // Cache tokens reduce the regular input cost
+    // 100K total input, 50K cache read, 20K cache write
+    // Regular input = 100K - 50K - 20K = 30K
+    const cost = calculateCost('claude-sonnet-4-6', {
+      inputTokens: 100_000,
+      outputTokens: 50_000,
+      cacheReadTokens: 50_000,
+      cacheWriteTokens: 20_000,
+    })
+
+    // Regular: 30K * $3/M = $0.09
+    // Output: 50K * $15/M = $0.75
+    // Cache read: 50K * $0.3/M = $0.015
+    // Cache write: 20K * $3.75/M = $0.075
+    const expected = 0.09 + 0.75 + 0.015 + 0.075
+    expect(cost).toBeCloseTo(expected, 4)
+  })
+
+  test('zero tokens = zero cost', () => {
+    const cost = calculateCost('claude-sonnet-4-6', {
+      inputTokens: 0,
+      outputTokens: 0,
+    })
+    expect(cost).toBe(0)
+  })
+
+  test('opus is significantly more expensive', () => {
+    const tokens = { inputTokens: 100_000, outputTokens: 10_000 }
+    const sonnetCost = calculateCost('claude-sonnet-4-6', tokens)
+    const opusCost = calculateCost('claude-opus-4-6', tokens)
+    expect(opusCost).toBeGreaterThan(sonnetCost * 3)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Catalog enumeration
+// ═══════════════════════════════════════════════════════════
+
+describe('listModels', () => {
+  test('returns all known models', () => {
+    const models = listModels()
+    expect(models.length).toBeGreaterThanOrEqual(7)
+    expect(models).toContain('claude-sonnet-4-6')
+    expect(models).toContain('claude-opus-4-6')
+    expect(models).toContain('claude-haiku-4-5')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Extended context [1m] variants
+// ═══════════════════════════════════════════════════════════
+
+describe('1M context variants', () => {
+  test('exact match for opus [1m] variant', () => {
+    const info = getModelInfo('claude-opus-4-6[1m]')
+    expect(info.displayName).toBe('Claude Opus 4.6 (1M)')
+    expect(info.contextWindow).toBe(1_000_000)
+    expect(info.maxOutput).toBe(128_000)
+  })
+
+  test('exact match for sonnet [1m] variant', () => {
+    const info = getModelInfo('claude-sonnet-4-6[1m]')
+    expect(info.displayName).toBe('Claude Sonnet 4.6 (1M)')
+    expect(info.contextWindow).toBe(1_000_000)
+  })
+
+  test('[1m] variant with date suffix is normalized correctly', () => {
+    const info = getModelInfo('claude-opus-4-6-20260301[1m]')
+    expect(info.displayName).toBe('Claude Opus 4.6 (1M)')
+    expect(info.contextWindow).toBe(1_000_000)
+  })
+
+  test('[1m] variant has premium pricing (2x input)', () => {
+    const standard = getModelInfo('claude-opus-4-6')
+    const extended = getModelInfo('claude-opus-4-6[1m]')
+    expect(extended.inputPricePerM).toBe(standard.inputPricePerM * 2)
+  })
+
+  test('[1m] variant has premium pricing (1.5x output)', () => {
+    const standard = getModelInfo('claude-opus-4-6')
+    const extended = getModelInfo('claude-opus-4-6[1m]')
+    expect(extended.outputPricePerM).toBe(standard.outputPricePerM * 1.5)
+  })
+
+  test('cost calculation uses [1m] premium pricing', () => {
+    const tokens = { inputTokens: 500_000, outputTokens: 10_000 }
+    const standardCost = calculateCost('claude-opus-4-6', tokens)
+    const extendedCost = calculateCost('claude-opus-4-6[1m]', tokens)
+    expect(extendedCost).toBeGreaterThan(standardCost)
+  })
+
+  test('[1m] variants are listed in catalog', () => {
+    const models = listModels()
+    expect(models).toContain('claude-opus-4-6[1m]')
+    expect(models).toContain('claude-sonnet-4-6[1m]')
+  })
+
+  test('regular date suffix normalization still works', () => {
+    // Ensure the [1m] changes didn't break normal normalization
+    const info = getModelInfo('claude-sonnet-4-5-20250514')
+    expect(info.displayName).toBe('Claude Sonnet 4.5')
+  })
+})

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

@@ -0,0 +1,185 @@
+/**
+ * /model Command — Test Suite
+ *
+ * Spec: view or change the active model at runtime.
+ *
+ * Key contracts:
+ * - No args: shows current model + available aliases
+ * - With alias (opus, sonnet, haiku, sonnet-4.5): sets model override
+ * - With full model ID: sets model override directly
+ * - /model clear or /model reset: removes override
+ * - When updateSessionMeta is not available: returns error
+ */
+import { describe, expect, test } from 'bun:test'
+import type { CommandContext } from '../lib/command-handler'
+import { modelCommand } from '../lib/commands/model'
+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' },
+      text: '/model',
+      timestamp: new Date(),
+    },
+    tracker: new SessionTracker(),
+    daemonStartedAt: Date.now(),
+    agent: { id: 'claude', name: 'Claude Code (CLI)' },
+    clearSession: async () => ({ sessionCleared: true, hooksRan: false }),
+    ...overrides,
+  }
+}
+
+// ═══════════════════════════════════════════════════════════
+// No args — show current model
+// ═══════════════════════════════════════════════════════════
+
+describe('/model no args', () => {
+  test('shows "Current Model" header', () => {
+    const result = modelCommand('', makeCtx())
+    expect(result).toContain('Current Model')
+  })
+
+  test('shows available aliases (opus, sonnet, haiku)', () => {
+    const result = modelCommand('', makeCtx())
+    expect(result).toContain('Available aliases')
+    expect(result).toContain('opus')
+    expect(result).toContain('sonnet')
+    expect(result).toContain('haiku')
+  })
+
+  test('shows current model from channelPersona.model', () => {
+    const ctx = makeCtx({
+      channelPersona: { model: 'claude-opus-4-6' } as any,
+    })
+    const result = modelCommand('', ctx)
+    expect(result).toContain('claude-opus-4-6')
+    expect(result).toContain('Claude Opus 4.6')
+  })
+
+  test('falls back to moon.model when no channelPersona.model', () => {
+    const ctx = makeCtx({
+      moon: { model: 'claude-haiku-4-5', name: 'TestMoon', systemPrompt: '', files: {} } as any,
+    })
+    const result = modelCommand('', ctx)
+    expect(result).toContain('claude-haiku-4-5')
+  })
+
+  test('shows "default" when neither channelPersona nor moon has model', () => {
+    const result = modelCommand('', makeCtx())
+    expect(result).toContain('default')
+  })
+
+  test('shows override hint when session has modelOverride', () => {
+    const ctx = makeCtx({
+      getSessionMeta: () => ({ modelOverride: 'claude-opus-4-6' }),
+    })
+    const result = modelCommand('', ctx)
+    expect(result).toContain('Override active')
+    expect(result).toContain('/model clear')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Set model with alias
+// ═══════════════════════════════════════════════════════════
+
+describe('/model set alias', () => {
+  test('/model opus sets claude-opus-4-6', () => {
+    let captured: unknown = null
+    const ctx = makeCtx({
+      updateSessionMeta: (u) => { captured = u },
+    })
+    modelCommand('opus', ctx)
+    expect(captured).toEqual({ modelOverride: 'claude-opus-4-6' })
+  })
+
+  test('/model sonnet sets claude-sonnet-4-6', () => {
+    let captured: unknown = null
+    const ctx = makeCtx({
+      updateSessionMeta: (u) => { captured = u },
+    })
+    modelCommand('sonnet', ctx)
+    expect(captured).toEqual({ modelOverride: 'claude-sonnet-4-6' })
+  })
+
+  test('/model haiku sets claude-haiku-4-5', () => {
+    let captured: unknown = null
+    const ctx = makeCtx({
+      updateSessionMeta: (u) => { captured = u },
+    })
+    modelCommand('haiku', ctx)
+    expect(captured).toEqual({ modelOverride: 'claude-haiku-4-5' })
+  })
+
+  test('/model with full ID sets it directly', () => {
+    let captured: unknown = null
+    const ctx = makeCtx({
+      updateSessionMeta: (u) => { captured = u },
+    })
+    modelCommand('claude-opus-4-6', ctx)
+    expect(captured).toEqual({ modelOverride: 'claude-opus-4-6' })
+  })
+
+  test('shows model display name in response after setting', () => {
+    const ctx = makeCtx({
+      updateSessionMeta: () => {},
+    })
+    const result = modelCommand('opus', ctx)
+    expect(result).toContain('Claude Opus 4.6')
+    expect(result).toContain('claude-opus-4-6')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Clear / Reset
+// ═══════════════════════════════════════════════════════════
+
+describe('/model clear and reset', () => {
+  test('/model clear calls updateSessionMeta with modelOverride null', () => {
+    let captured: unknown = null
+    const ctx = makeCtx({
+      updateSessionMeta: (u) => { captured = u },
+    })
+    modelCommand('clear', ctx)
+    expect(captured).toEqual({ modelOverride: null })
+  })
+
+  test('/model reset also clears', () => {
+    let captured: unknown = null
+    const ctx = makeCtx({
+      updateSessionMeta: (u) => { captured = u },
+    })
+    modelCommand('reset', ctx)
+    expect(captured).toEqual({ modelOverride: null })
+  })
+
+  test('/model clear shows reverted model', () => {
+    const ctx = makeCtx({
+      updateSessionMeta: () => {},
+      channelPersona: { model: 'claude-sonnet-4-6' } as any,
+    })
+    const result = modelCommand('clear', ctx)
+    expect(result).toContain('override cleared')
+    expect(result).toContain('claude-sonnet-4-6')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Error: updateSessionMeta not available
+// ═══════════════════════════════════════════════════════════
+
+describe('/model without updateSessionMeta', () => {
+  test('returns "not available" when setting model without updateSessionMeta', () => {
+    const result = modelCommand('opus', makeCtx())
+    expect(result).toContain('not available')
+  })
+
+  test('returns "not available" when clearing without updateSessionMeta', () => {
+    const result = modelCommand('clear', makeCtx())
+    expect(result).toContain('not available')
+  })
+})