@onmars/lunar-core 0.1.0

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

@@ -0,0 +1,146 @@
+/**
+ * /think Command — Test Suite
+ *
+ * Spec: set the thinking level for the current session.
+ *
+ * Key contracts:
+ * - No args: shows current level + available options
+ * - Valid levels: off, low, medium, high
+ * - Each level shows a description after being set
+ * - Invalid level: error with available options listed
+ * - When updateSessionMeta is not available: returns error
+ */
+import { describe, expect, test } from 'bun:test'
+import type { CommandContext } from '../lib/command-handler'
+import { thinkCommand } from '../lib/commands/think'
+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: '/think',
+      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 level
+// ═══════════════════════════════════════════════════════════
+
+describe('/think no args', () => {
+  test('shows "default" when no metadata', () => {
+    const result = thinkCommand('', makeCtx())
+    expect(result).toContain('default')
+  })
+
+  test('shows current level from session metadata', () => {
+    const ctx = makeCtx({
+      getSessionMeta: () => ({ thinkingLevel: 'high' }),
+    })
+    const result = thinkCommand('', ctx)
+    expect(result).toContain('high')
+  })
+
+  test('shows available levels list', () => {
+    const result = thinkCommand('', makeCtx())
+    expect(result).toContain('off')
+    expect(result).toContain('low')
+    expect(result).toContain('medium')
+    expect(result).toContain('high')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Set thinking level
+// ═══════════════════════════════════════════════════════════
+
+describe('/think set level', () => {
+  test('/think off sets thinkingLevel to off', () => {
+    let captured: unknown = null
+    const ctx = makeCtx({
+      updateSessionMeta: (u) => { captured = u },
+    })
+    thinkCommand('off', ctx)
+    expect(captured).toEqual({ thinkingLevel: 'off' })
+  })
+
+  test('/think low sets thinkingLevel to low', () => {
+    let captured: unknown = null
+    const ctx = makeCtx({
+      updateSessionMeta: (u) => { captured = u },
+    })
+    thinkCommand('low', ctx)
+    expect(captured).toEqual({ thinkingLevel: 'low' })
+  })
+
+  test('/think medium sets thinkingLevel to medium', () => {
+    let captured: unknown = null
+    const ctx = makeCtx({
+      updateSessionMeta: (u) => { captured = u },
+    })
+    thinkCommand('medium', ctx)
+    expect(captured).toEqual({ thinkingLevel: 'medium' })
+  })
+
+  test('/think high sets thinkingLevel to high', () => {
+    let captured: unknown = null
+    const ctx = makeCtx({
+      updateSessionMeta: (u) => { captured = u },
+    })
+    thinkCommand('high', ctx)
+    expect(captured).toEqual({ thinkingLevel: 'high' })
+  })
+
+  test('shows description for each level', () => {
+    const ctx = makeCtx({ updateSessionMeta: () => {} })
+
+    const offResult = thinkCommand('off', ctx)
+    expect(offResult).toContain('fastest')
+
+    const lowResult = thinkCommand('low', ctx)
+    expect(lowResult).toContain('Brief')
+
+    const medResult = thinkCommand('medium', ctx)
+    expect(medResult).toContain('Moderate')
+
+    const highResult = thinkCommand('high', ctx)
+    expect(highResult).toContain('Deep')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Invalid level
+// ═══════════════════════════════════════════════════════════
+
+describe('/think invalid level', () => {
+  test('shows error with available options', () => {
+    const result = thinkCommand('turbo', makeCtx())
+    expect(result).toContain('Invalid level')
+    expect(result).toContain('turbo')
+    expect(result).toContain('off')
+    expect(result).toContain('low')
+    expect(result).toContain('medium')
+    expect(result).toContain('high')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Error: updateSessionMeta not available
+// ═══════════════════════════════════════════════════════════
+
+describe('/think without updateSessionMeta', () => {
+  test('returns "not available" when setting level', () => {
+    const result = thinkCommand('high', makeCtx())
+    expect(result).toContain('not available')
+  })
+})

package/src/__tests__/usage-api.test.ts

@@ -0,0 +1,222 @@
+/**
+ * # Usage API — Tests
+ *
+ * Tests the exported functions from usage-api.ts:
+ * - readOAuthToken() — reads from env var or ~/.claude/.credentials.json
+ * - parseWindow() — parses raw usage window data
+ * - hasOAuthCredentials() — checks if OAuth token is available
+ * - fetchAccountUsage() — calls Anthropic's usage endpoint
+ *
+ * All functions are imported from the real module. No reimplementation.
+ *
+ * NOTE: readOAuthToken uses homedir() which cannot be overridden at runtime
+ * in Bun (it's cached). Tests for the env-var path work directly. Tests for
+ * the file-reading path are validated through hasOAuthCredentials + fetchAccountUsage
+ * integration, and parseWindow is tested thoroughly as a pure function.
+ */
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test'
+import {
+  fetchAccountUsage,
+  hasOAuthCredentials,
+  parseWindow,
+  readOAuthToken,
+} from '../lib/usage-api'
+
+// Save original env
+let savedOAuthToken: string | undefined
+
+beforeEach(() => {
+  savedOAuthToken = process.env.CLAUDE_CODE_OAUTH_TOKEN
+  delete process.env.CLAUDE_CODE_OAUTH_TOKEN
+})
+
+afterEach(() => {
+  if (savedOAuthToken !== undefined) {
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = savedOAuthToken
+  } else {
+    delete process.env.CLAUDE_CODE_OAUTH_TOKEN
+  }
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// readOAuthToken — env var path
+// ═══════════════════════════════════════════════════════════════════
+
+describe('readOAuthToken', () => {
+  it('returns env var token when CLAUDE_CODE_OAUTH_TOKEN is set', () => {
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = 'env-oauth-token'
+    expect(readOAuthToken()).toBe('env-oauth-token')
+  })
+
+  it('env var takes precedence — always returns env token regardless of file', () => {
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = 'env-wins'
+    // Even if ~/.claude/.credentials.json exists, env var wins
+    expect(readOAuthToken()).toBe('env-wins')
+  })
+
+  it('returns a string or null without env var (depends on real credentials file)', () => {
+    // Without env var, falls back to ~/.claude/.credentials.json
+    // In environments with real Claude credentials, returns a token string.
+    // In clean environments, returns null.
+    const result = readOAuthToken()
+    expect(result === null || typeof result === 'string').toBe(true)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// parseWindow — usage window parsing (pure function, fully testable)
+// ═══════════════════════════════════════════════════════════════════
+
+describe('parseWindow', () => {
+  it('returns null for null input', () => {
+    expect(parseWindow(null)).toBeNull()
+  })
+
+  it('returns null for undefined input', () => {
+    expect(parseWindow(undefined)).toBeNull()
+  })
+
+  it('returns null for non-object input', () => {
+    expect(parseWindow('string')).toBeNull()
+    expect(parseWindow(42)).toBeNull()
+    expect(parseWindow(true)).toBeNull()
+  })
+
+  it('parses valid usage window with all fields', () => {
+    const result = parseWindow({
+      used: 50000,
+      limit: 100000,
+      resetsAt: '2026-04-05T15:00:00Z',
+    })
+    expect(result).toEqual({
+      used: 50000,
+      limit: 100000,
+      percent: 50,
+      resetsAt: '2026-04-05T15:00:00Z',
+    })
+  })
+
+  it('calculates percent correctly', () => {
+    const result = parseWindow({ used: 75000, limit: 100000 })
+    expect(result!.percent).toBe(75)
+  })
+
+  it('rounds percent to nearest integer', () => {
+    const result = parseWindow({ used: 33333, limit: 100000 })
+    expect(result!.percent).toBe(33)
+  })
+
+  it('handles 100% usage', () => {
+    const result = parseWindow({ used: 100000, limit: 100000 })
+    expect(result!.percent).toBe(100)
+  })
+
+  it('handles over 100% usage', () => {
+    const result = parseWindow({ used: 150000, limit: 100000 })
+    expect(result!.percent).toBe(150)
+  })
+
+  it('returns 0 percent when limit is 0', () => {
+    const result = parseWindow({ used: 50000, limit: 0 })
+    expect(result!.percent).toBe(0)
+  })
+
+  it('defaults used to 0 when not a number', () => {
+    const result = parseWindow({ used: 'invalid', limit: 100000 })
+    expect(result!.used).toBe(0)
+    expect(result!.percent).toBe(0)
+  })
+
+  it('defaults limit to 0 when not a number', () => {
+    const result = parseWindow({ used: 50000, limit: 'invalid' })
+    expect(result!.limit).toBe(0)
+    expect(result!.percent).toBe(0)
+  })
+
+  it('returns undefined resetsAt when not a string', () => {
+    const result = parseWindow({ used: 50000, limit: 100000, resetsAt: 12345 })
+    expect(result!.resetsAt).toBeUndefined()
+  })
+
+  it('handles empty object', () => {
+    const result = parseWindow({})
+    expect(result).toEqual({
+      used: 0,
+      limit: 0,
+      percent: 0,
+      resetsAt: undefined,
+    })
+  })
+
+  it('composes correctly for a full API response', () => {
+    const apiResponse = {
+      five_hour: { used: 50000, limit: 100000, resetsAt: '2026-04-05T20:00:00Z' },
+      seven_day: { used: 200000, limit: 500000, resetsAt: '2026-04-12T00:00:00Z' },
+    }
+
+    const fiveHour = parseWindow(apiResponse.five_hour)
+    const sevenDay = parseWindow(apiResponse.seven_day)
+
+    expect(fiveHour).toEqual({
+      used: 50000,
+      limit: 100000,
+      percent: 50,
+      resetsAt: '2026-04-05T20:00:00Z',
+    })
+    expect(sevenDay).toEqual({
+      used: 200000,
+      limit: 500000,
+      percent: 40,
+      resetsAt: '2026-04-12T00:00:00Z',
+    })
+  })
+
+  it('handles missing windows in API response', () => {
+    const apiResponse: Record<string, unknown> = {}
+    expect(parseWindow(apiResponse.five_hour)).toBeNull()
+    expect(parseWindow(apiResponse.seven_day)).toBeNull()
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// hasOAuthCredentials
+// ═══════════════════════════════════════════════════════════════════
+
+describe('hasOAuthCredentials', () => {
+  it('returns true when env var is set', () => {
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = 'test-token'
+    expect(hasOAuthCredentials()).toBe(true)
+  })
+
+  it('returns a boolean without env var (depends on real credentials)', () => {
+    // On machines with ~/.claude/.credentials.json: true
+    // On clean machines: false
+    expect(typeof hasOAuthCredentials()).toBe('boolean')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// fetchAccountUsage — integration
+// ═══════════════════════════════════════════════════════════════════
+
+describe('fetchAccountUsage', () => {
+  it('returns null on API error (invalid token)', async () => {
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = 'invalid-token-for-test'
+    const result = await fetchAccountUsage()
+    expect(result).toBeNull()
+  })
+
+  it('returns AccountUsage shape or null with env token', async () => {
+    process.env.CLAUDE_CODE_OAUTH_TOKEN = 'another-invalid-token'
+    const result = await fetchAccountUsage()
+    // Invalid token should fail authentication
+    if (result !== null) {
+      expect(result).toHaveProperty('fiveHour')
+      expect(result).toHaveProperty('sevenDay')
+      expect(result).toHaveProperty('fetchedAt')
+      expect(result.fetchedAt).toBeGreaterThan(0)
+    } else {
+      expect(result).toBeNull()
+    }
+  })
+})

package/src/__tests__/usage-command-api-fail.test.ts

@@ -0,0 +1,48 @@
+/**
+ * /usage Command — API Failure Tests
+ *
+ * Separate file because mock.module is file-scoped.
+ * Tests behavior when OAuth is available but API call fails.
+ */
+
+import { mock } from 'bun:test'
+
+mock.module('../lib/usage-api', () => ({
+  hasOAuthCredentials: () => true,
+  fetchAccountUsage: async () => null,
+}))
+
+import { describe, expect, test } from 'bun:test'
+import type { CommandContext } from '../lib/command-handler'
+import { usageCommand } from '../lib/commands/usage'
+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: '/usage',
+      timestamp: new Date(),
+    },
+    tracker: new SessionTracker(),
+    daemonStartedAt: Date.now(),
+    agent: { id: 'claude', name: 'Claude Code (CLI)' },
+    clearSession: async () => ({ sessionCleared: true, hooksRan: false }),
+    ...overrides,
+  }
+}
+
+describe('/usage API failure', () => {
+  test('shows "could not fetch quota" when API returns null', async () => {
+    const result = await usageCommand('', makeCtx())
+    expect(result).toContain('could not fetch quota')
+  })
+
+  test('does not show Account Quota section', async () => {
+    const result = await usageCommand('', makeCtx())
+    expect(result).not.toContain('**Account Quota:**')
+  })
+})

package/src/__tests__/usage-command-no-oauth.test.ts

@@ -0,0 +1,48 @@
+/**
+ * /usage Command — No OAuth Tests
+ *
+ * Separate file because mock.module is file-scoped.
+ * Tests behavior when OAuth credentials are not available.
+ */
+
+import { mock } from 'bun:test'
+
+mock.module('../lib/usage-api', () => ({
+  hasOAuthCredentials: () => false,
+  fetchAccountUsage: async () => null,
+}))
+
+import { describe, expect, test } from 'bun:test'
+import type { CommandContext } from '../lib/command-handler'
+import { usageCommand } from '../lib/commands/usage'
+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: '/usage',
+      timestamp: new Date(),
+    },
+    tracker: new SessionTracker(),
+    daemonStartedAt: Date.now(),
+    agent: { id: 'claude', name: 'Claude Code (CLI)' },
+    clearSession: async () => ({ sessionCleared: true, hooksRan: false }),
+    ...overrides,
+  }
+}
+
+describe('/usage no OAuth', () => {
+  test('shows "no OAuth credentials" when no token available', async () => {
+    const result = await usageCommand('', makeCtx())
+    expect(result).toContain('no OAuth credentials')
+  })
+
+  test('does not show Account Quota section', async () => {
+    const result = await usageCommand('', makeCtx())
+    expect(result).not.toContain('**Account Quota:**')
+  })
+})

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

@@ -0,0 +1,173 @@
+/**
+ * /usage Command — Test Suite
+ *
+ * Spec: shows session usage (tokens, turns, cost) and account quota
+ * (5h/7d rolling windows from Anthropic OAuth API).
+ *
+ * Key contracts:
+ * - Shows session token counts when session exists
+ * - Shows "no queries yet" when no session data
+ * - Shows cost estimate
+ * - Shows account quota progress bars when OAuth available
+ * - Shows "no OAuth credentials" when no token
+ * - Shows "could not fetch" when API fails
+ *
+ * Mocking: usage-api is mocked per describe block to control
+ * hasOAuthCredentials and fetchAccountUsage behavior.
+ */
+
+// ═══════════════════════════════════════════════════════════
+// Tests WITH OAuth credentials (quota available)
+// ═══════════════════════════════════════════════════════════
+
+import { mock } from 'bun:test'
+
+// Default mock: OAuth available with quota data
+mock.module('../lib/usage-api', () => ({
+  hasOAuthCredentials: () => true,
+  fetchAccountUsage: async () => ({
+    fiveHour: { used: 50000, limit: 100000, percent: 50 },
+    sevenDay: { used: 200000, limit: 1000000, percent: 20 },
+    fetchedAt: Date.now(),
+  }),
+}))
+
+import { describe, expect, test } from 'bun:test'
+import type { CommandContext } from '../lib/command-handler'
+import { usageCommand } from '../lib/commands/usage'
+import { SessionTracker } from '../lib/session-tracker'
+import type { Moon } from '../types/moon'
+
+function makeMoon(overrides?: Partial<Moon>): Moon {
+  return {
+    name: 'TestMoon',
+    soul: '',
+    agents: '',
+    identity: '',
+    path: '/tmp/test',
+    ...overrides,
+  }
+}
+
+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: '/usage',
+      timestamp: new Date(),
+    },
+    tracker: new SessionTracker(),
+    daemonStartedAt: Date.now(),
+    agent: { id: 'claude', name: 'Claude Code (CLI)' },
+    clearSession: async () => ({ sessionCleared: true, hooksRan: false }),
+    ...overrides,
+  }
+}
+
+function makeCtxWithUsage(opts?: { moon?: Moon }): CommandContext {
+  const tracker = new SessionTracker()
+
+  tracker.recordQuery('test:channel-1', {
+    inputTokens: 5000,
+    outputTokens: 2000,
+    cacheReadTokens: 150000,
+    cacheWriteTokens: 10000,
+    contextTokens: 165000,
+    model: 'claude-opus-4-6-20260301',
+    durationMs: 12000,
+  })
+  tracker.recordMessage('test:channel-1')
+
+  return makeCtx({ tracker, moon: opts?.moon ?? makeMoon() })
+}
+
+// ═══════════════════════════════════════════════════════════
+// Header
+// ═══════════════════════════════════════════════════════════
+
+describe('/usage header', () => {
+  test('shows moon name in header', async () => {
+    const ctx = makeCtx({ moon: makeMoon({ name: 'Deimos' }) })
+    const result = await usageCommand('', ctx)
+    expect(result).toContain('**Deimos** — Usage')
+  })
+
+  test('defaults to "Lunar" when no moon', async () => {
+    const result = await usageCommand('', makeCtx())
+    expect(result).toContain('**Lunar** — Usage')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Session usage
+// ═══════════════════════════════════════════════════════════
+
+describe('/usage session', () => {
+  test('shows session tokens when session exists', async () => {
+    const result = await usageCommand('', makeCtxWithUsage())
+    expect(result).toContain('**Session:**')
+    expect(result).toContain('Tokens:')
+    expect(result).toContain('in /')
+    expect(result).toContain('out')
+  })
+
+  test('shows turns and messages', async () => {
+    const result = await usageCommand('', makeCtxWithUsage())
+    expect(result).toContain('Turns: 1')
+    expect(result).toContain('Messages: 1')
+  })
+
+  test('shows "no queries yet" when no session', async () => {
+    const result = await usageCommand('', makeCtx())
+    expect(result).toContain('**Session:** no queries yet')
+  })
+
+  test('shows cost estimate', async () => {
+    const result = await usageCommand('', makeCtxWithUsage())
+    // Cost should be present as either <$0.01 or ~$X.XX
+    expect(result).toMatch(/Cost:.*(\$|<)/)
+  })
+
+  test('shows model display name', async () => {
+    const result = await usageCommand('', makeCtxWithUsage())
+    expect(result).toContain('Model:')
+  })
+
+  test('shows session duration', async () => {
+    const result = await usageCommand('', makeCtxWithUsage())
+    expect(result).toContain('Duration:')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Account quota (OAuth available — default mock)
+// ═══════════════════════════════════════════════════════════
+
+describe('/usage account quota', () => {
+  test('shows account quota section', async () => {
+    const result = await usageCommand('', makeCtx())
+    expect(result).toContain('**Account Quota:**')
+  })
+
+  test('shows 5h progress bar with percentage', async () => {
+    const result = await usageCommand('', makeCtx())
+    expect(result).toContain('5h:')
+    expect(result).toContain('50%')
+  })
+
+  test('shows 7d progress bar with percentage', async () => {
+    const result = await usageCommand('', makeCtx())
+    expect(result).toContain('7d:')
+    expect(result).toContain('20%')
+  })
+
+  test('shows progress bars with block characters', async () => {
+    const result = await usageCommand('', makeCtx())
+    // Progress bars use █ and ░
+    expect(result).toContain('█')
+    expect(result).toContain('░')
+  })
+})