@onmars/lunar-core 0.1.0

package/src/__tests__/session-meta.test.ts

@@ -0,0 +1,101 @@
+/**
+ * SessionStore Metadata — Test Suite
+ *
+ * Spec: updateMetadata and getMetadata methods on SessionStore.
+ *
+ * Key contracts:
+ * - getMetadata returns null when no session exists
+ * - updateMetadata creates a placeholder session if none exists
+ * - getMetadata returns parsed JSON after updateMetadata
+ * - updateMetadata replaces metadata (merging is done by caller)
+ * - getMetadata returns null for invalid JSON
+ * - updateMetadata on existing session preserves agent_session_id
+ */
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import { mkdtempSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { SessionStore } from '../lib/session'
+
+let store: SessionStore
+let tmpDir: string
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), 'lunar-test-'))
+  store = new SessionStore(join(tmpDir, 'test.db'))
+})
+
+afterEach(() => {
+  store.close()
+  rmSync(tmpDir, { recursive: true, force: true })
+})
+
+// ═══════════════════════════════════════════════════════════
+// getMetadata
+// ═══════════════════════════════════════════════════════════
+
+describe('getMetadata', () => {
+  test('returns null when no session exists', () => {
+    const result = store.getMetadata('nonexistent:key')
+    expect(result).toBeNull()
+  })
+
+  test('returns null for session without metadata', () => {
+    store.set('test:key', 'session-1')
+    const result = store.getMetadata('test:key')
+    expect(result).toBeNull()
+  })
+
+  test('returns parsed JSON after updateMetadata', () => {
+    store.updateMetadata('test:key', '{"a":1}')
+    const result = store.getMetadata('test:key')
+    expect(result).toEqual({ a: 1 })
+  })
+
+  test('returns null for invalid JSON', () => {
+    store.updateMetadata('test:key', 'not-json{')
+    const result = store.getMetadata('test:key')
+    expect(result).toBeNull()
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// updateMetadata
+// ═══════════════════════════════════════════════════════════
+
+describe('updateMetadata', () => {
+  test('creates placeholder session if none exists', () => {
+    store.updateMetadata('new:key', '{"foo":"bar"}')
+    const session = store.get('new:key')
+    expect(session).not.toBeNull()
+    expect(session!.key).toBe('new:key')
+    expect(session!.metadata).toBe('{"foo":"bar"}')
+  })
+
+  test('replaces metadata on subsequent calls', () => {
+    store.updateMetadata('test:key', '{"a":1}')
+    store.updateMetadata('test:key', '{"b":2}')
+    const result = store.getMetadata('test:key')
+    expect(result).toEqual({ b: 2 })
+  })
+
+  test('preserves agent_session_id on existing session', () => {
+    store.set('test:key', 'my-session-id')
+    store.updateMetadata('test:key', '{"override":"opus"}')
+    const session = store.get('test:key')
+    expect(session).not.toBeNull()
+    // updateMetadata uses ON CONFLICT DO UPDATE SET metadata only,
+    // so agent_session_id should remain from the original INSERT
+    // Actually, looking at the SQL: it does INSERT with '' as agent_session_id
+    // and ON CONFLICT updates only metadata + last_active.
+    // So existing agent_session_id is preserved.
+    expect(session!.agentSessionId).toBe('my-session-id')
+  })
+
+  test('placeholder session has empty agent_session_id', () => {
+    store.updateMetadata('new:key', '{"x":1}')
+    const session = store.get('new:key')
+    expect(session).not.toBeNull()
+    expect(session!.agentSessionId).toBe('')
+  })
+})

package/src/__tests__/session-tracker.test.ts

@@ -0,0 +1,389 @@
+/**
+ * Session Tracker — Test Suite
+ *
+ * Spec: accumulates token usage per session from AgentEvent 'done' events.
+ * Provides session status with context %, cost estimates, and formatted output.
+ *
+ * Key contracts:
+ * - Accumulates tokens across multiple queries
+ * - Tracks cache tokens separately
+ * - Calculates context usage from last query's input tokens
+ * - Provides cost estimates via model-catalog pricing
+ * - Formatting helpers produce human-readable output
+ */
+import { describe, expect, test } from 'bun:test'
+import {
+  buildProgressBar,
+  formatDuration,
+  formatTokens,
+  SessionTracker,
+} from '../lib/session-tracker'
+
+// ═══════════════════════════════════════════════════════════
+// Token accumulation
+// ═══════════════════════════════════════════════════════════
+
+describe('SessionTracker accumulation', () => {
+  test('first query initializes session', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('session-1', {
+      inputTokens: 5000,
+      outputTokens: 1000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 2000,
+    })
+
+    const usage = tracker.getUsage('session-1')
+    expect(usage).toBeDefined()
+    expect(usage!.inputTokens).toBe(5000)
+    expect(usage!.outputTokens).toBe(1000)
+    expect(usage!.queryCount).toBe(1)
+    expect(usage!.model).toBe('claude-sonnet-4-6')
+  })
+
+  test('multiple queries accumulate tokens', () => {
+    const tracker = new SessionTracker()
+
+    tracker.recordQuery('s1', {
+      inputTokens: 5000,
+      outputTokens: 1000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 1000,
+    })
+    tracker.recordQuery('s1', {
+      inputTokens: 10000,
+      outputTokens: 2000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 1500,
+    })
+
+    const usage = tracker.getUsage('s1')!
+    expect(usage.inputTokens).toBe(15000)
+    expect(usage.outputTokens).toBe(3000)
+    expect(usage.queryCount).toBe(2)
+    expect(usage.totalApiDurationMs).toBe(2500)
+  })
+
+  test('cache tokens tracked separately', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('s1', {
+      inputTokens: 10000,
+      outputTokens: 2000,
+      cacheReadTokens: 5000,
+      cacheWriteTokens: 3000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 1000,
+    })
+
+    const usage = tracker.getUsage('s1')!
+    expect(usage.cacheReadTokens).toBe(5000)
+    expect(usage.cacheWriteTokens).toBe(3000)
+  })
+
+  test('lastContextTokens updated per query', () => {
+    const tracker = new SessionTracker()
+
+    tracker.recordQuery('s1', {
+      inputTokens: 5000,
+      outputTokens: 1000,
+      contextTokens: 50_000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 1000,
+    })
+    expect(tracker.getUsage('s1')!.lastContextTokens).toBe(50_000)
+
+    tracker.recordQuery('s1', {
+      inputTokens: 10000,
+      outputTokens: 2000,
+      contextTokens: 80_000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 1500,
+    })
+    expect(tracker.getUsage('s1')!.lastContextTokens).toBe(80_000)
+  })
+
+  test('lastContextTokens falls back to input + cache when contextTokens not provided', () => {
+    const tracker = new SessionTracker()
+
+    tracker.recordQuery('s1', {
+      inputTokens: 5000,
+      outputTokens: 1000,
+      cacheReadTokens: 40_000,
+      cacheWriteTokens: 10_000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 1000,
+    })
+    // 5000 + 40000 + 10000 = 55000
+    expect(tracker.getUsage('s1')!.lastContextTokens).toBe(55_000)
+  })
+
+  test('model updated to latest', () => {
+    const tracker = new SessionTracker()
+
+    tracker.recordQuery('s1', {
+      inputTokens: 5000,
+      outputTokens: 1000,
+      model: 'claude-sonnet-4-5',
+      durationMs: 1000,
+    })
+    tracker.recordQuery('s1', {
+      inputTokens: 10000,
+      outputTokens: 2000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 1500,
+    })
+
+    expect(tracker.getUsage('s1')!.model).toBe('claude-sonnet-4-6')
+  })
+
+  test('message count tracked separately from queries', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('s1', {
+      inputTokens: 5000,
+      outputTokens: 1000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 1000,
+    })
+    tracker.recordMessage('s1')
+    tracker.recordMessage('s1')
+
+    expect(tracker.getUsage('s1')!.messageCount).toBe(2)
+  })
+
+  test('recordMessage on unknown session is a no-op', () => {
+    const tracker = new SessionTracker()
+    tracker.recordMessage('nonexistent')
+    expect(tracker.getUsage('nonexistent')).toBeUndefined()
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Session status
+// ═══════════════════════════════════════════════════════════
+
+describe('SessionTracker.getStatus', () => {
+  test('returns null for unknown session', () => {
+    const tracker = new SessionTracker()
+    expect(tracker.getStatus('unknown')).toBeNull()
+  })
+
+  test('calculates context percentage from contextTokens', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('s1', {
+      inputTokens: 10_000,
+      outputTokens: 5000,
+      contextTokens: 100_000, // 50% of 200K
+      model: 'claude-sonnet-4-6',
+      durationMs: 3000,
+    })
+
+    const status = tracker.getStatus('s1')!
+    expect(status.contextWindowSize).toBe(200_000)
+    expect(status.contextUsedPercent).toBeCloseTo(50, 0)
+  })
+
+  test('context with no contextTokens falls back to input + cache', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('s1', {
+      inputTokens: 50_000,
+      outputTokens: 5000,
+      cacheReadTokens: 50_000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 3000,
+    })
+
+    const status = tracker.getStatus('s1')!
+    // 50K + 50K = 100K = 50%
+    expect(status.contextUsedPercent).toBeCloseTo(50, 0)
+  })
+
+  test('context capped at 100%', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('s1', {
+      inputTokens: 10_000,
+      outputTokens: 5000,
+      contextTokens: 250_000, // over 200K limit
+      model: 'claude-sonnet-4-6',
+      durationMs: 3000,
+    })
+
+    const status = tracker.getStatus('s1')!
+    expect(status.contextUsedPercent).toBe(100)
+  })
+
+  test('provides cost estimate', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('s1', {
+      inputTokens: 100_000,
+      outputTokens: 10_000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 3000,
+    })
+
+    const status = tracker.getStatus('s1')!
+    expect(status.estimatedCostUsd).toBeGreaterThan(0)
+  })
+
+  test('provides model display name', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('s1', {
+      inputTokens: 5000,
+      outputTokens: 1000,
+      model: 'claude-opus-4-6',
+      durationMs: 1000,
+    })
+
+    const status = tracker.getStatus('s1')!
+    expect(status.modelDisplayName).toBe('Claude Opus 4.6')
+  })
+
+  test('session age increases over time', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('s1', {
+      inputTokens: 5000,
+      outputTokens: 1000,
+      model: 'claude-sonnet-4-6',
+      durationMs: 1000,
+    })
+
+    const status = tracker.getStatus('s1')!
+    expect(status.sessionAgeMs).toBeGreaterThanOrEqual(0)
+    expect(status.sessionAge).toBeTruthy()
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Session lifecycle
+// ═══════════════════════════════════════════════════════════
+
+describe('SessionTracker lifecycle', () => {
+  test('listSessions returns tracked sessions', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('s1', {
+      inputTokens: 100,
+      outputTokens: 50,
+      durationMs: 100,
+      model: 'test',
+    })
+    tracker.recordQuery('s2', {
+      inputTokens: 200,
+      outputTokens: 100,
+      durationMs: 200,
+      model: 'test',
+    })
+
+    const sessions = tracker.listSessions()
+    expect(sessions).toContain('s1')
+    expect(sessions).toContain('s2')
+  })
+
+  test('clear removes a specific session', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('s1', {
+      inputTokens: 100,
+      outputTokens: 50,
+      durationMs: 100,
+      model: 'test',
+    })
+    tracker.recordQuery('s2', {
+      inputTokens: 200,
+      outputTokens: 100,
+      durationMs: 200,
+      model: 'test',
+    })
+
+    tracker.clear('s1')
+    expect(tracker.getUsage('s1')).toBeUndefined()
+    expect(tracker.getUsage('s2')).toBeDefined()
+  })
+
+  test('clearAll removes everything', () => {
+    const tracker = new SessionTracker()
+    tracker.recordQuery('s1', {
+      inputTokens: 100,
+      outputTokens: 50,
+      durationMs: 100,
+      model: 'test',
+    })
+    tracker.recordQuery('s2', {
+      inputTokens: 200,
+      outputTokens: 100,
+      durationMs: 200,
+      model: 'test',
+    })
+
+    tracker.clearAll()
+    expect(tracker.listSessions()).toHaveLength(0)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════
+// Formatting helpers
+// ═══════════════════════════════════════════════════════════
+
+describe('formatDuration', () => {
+  test('seconds only', () => {
+    expect(formatDuration(45_000)).toBe('45s')
+  })
+
+  test('minutes and seconds', () => {
+    expect(formatDuration(125_000)).toBe('2m 5s')
+  })
+
+  test('minutes only (exact)', () => {
+    expect(formatDuration(300_000)).toBe('5m')
+  })
+
+  test('hours and minutes', () => {
+    expect(formatDuration(7_380_000)).toBe('2h 3m')
+  })
+
+  test('hours only (exact)', () => {
+    expect(formatDuration(3_600_000)).toBe('1h')
+  })
+
+  test('zero', () => {
+    expect(formatDuration(0)).toBe('0s')
+  })
+})
+
+describe('formatTokens', () => {
+  test('small numbers as-is', () => {
+    expect(formatTokens(850)).toBe('850')
+  })
+
+  test('thousands with decimal', () => {
+    expect(formatTokens(1_234)).toBe('1.2K')
+  })
+
+  test('tens of thousands rounded', () => {
+    expect(formatTokens(12_450)).toBe('12K')
+  })
+
+  test('millions with decimal', () => {
+    expect(formatTokens(1_500_000)).toBe('1.5M')
+  })
+})
+
+describe('buildProgressBar', () => {
+  test('0% is all empty', () => {
+    expect(buildProgressBar(0, 10)).toBe('░░░░░░░░░░')
+  })
+
+  test('100% is all filled', () => {
+    expect(buildProgressBar(100, 10)).toBe('██████████')
+  })
+
+  test('50% is half filled', () => {
+    expect(buildProgressBar(50, 10)).toBe('█████░░░░░')
+  })
+
+  test('clamped to 0-100', () => {
+    expect(buildProgressBar(-10, 10)).toBe('░░░░░░░░░░')
+    expect(buildProgressBar(150, 10)).toBe('██████████')
+  })
+
+  test('custom width', () => {
+    expect(buildProgressBar(50, 20)).toBe('██████████░░░░░░░░░░')
+  })
+})