| |
| |
| |
| |
|
|
| import type { StepMessage, TurnMessage } from '@moonshot-ai/kap-server/protocol'; |
| import { describe, expect, it } from 'vitest'; |
|
|
| import { EMPTY_CHAT_STATE, type ChatState } from '../transcript/store'; |
| import { diffValue, type DiffNode } from './diff'; |
| import { serializeState } from './serialize'; |
| import { AuditTrail, AUDIT_TRAIL_MAX_ENTRIES } from './trail'; |
| import { tailTrunc } from './truncate'; |
|
|
| const T0 = Date.parse('2026-01-01T00:00:00.000Z'); |
| let tick = 0; |
|
|
| function ts(): number { |
| tick += 1; |
| return T0 + tick * 1000; |
| } |
|
|
| function turnMsg(n: number, status: 'running' | 'completed' = 'completed'): TurnMessage { |
| return { |
| type: 'turn', |
| session_id: 's1', |
| agent_id: 'main', |
| timestamp: ts(), |
| turn_id: `t${n}`, |
| ordinal: n, |
| status, |
| origin: { kind: 'user' }, |
| }; |
| } |
|
|
| function stepMsg(stepId: string, status: 'running' | 'completed'): StepMessage { |
| return { |
| type: 'step', |
| session_id: 's1', |
| agent_id: 'main', |
| timestamp: ts(), |
| step_id: stepId, |
| turn_id: stepId.split('.')[0] ?? 't1', |
| ordinal: Number(stepId.split('.')[1] ?? '1'), |
| status, |
| }; |
| } |
|
|
| function stateWithTimeline(items: readonly (TurnMessage | StepMessage)[]): ChatState { |
| return { |
| ...EMPTY_CHAT_STATE, |
| entries: items.map((message) => ({ |
| key: message.type === 'turn' ? `turn:${message.turn_id}` : `step:${message.step_id}`, |
| message, |
| })), |
| }; |
| } |
|
|
| |
|
|
| describe('diffValue', () => { |
| it('collapses reference-equal subtrees to unchanged without children', () => { |
| const shared = { a: 1, b: { c: 'x' } }; |
| const node = diffValue({ v: shared }, { v: shared }); |
| expect(node.status).toBe('unchanged'); |
| expect(node.children?.get('v')?.children).toBeUndefined(); |
| }); |
|
|
| it('marks added, removed, and modified object keys', () => { |
| const node = diffValue( |
| { keep: 1, gone: 'x', changed: 'a' }, |
| { keep: 1, fresh: true, changed: 'b' }, |
| ); |
| expect(node.status).toBe('modified'); |
| expect(node.children?.get('keep')?.status).toBe('unchanged'); |
| expect(node.children?.get('fresh')?.status).toBe('added'); |
| expect(node.children?.get('gone')).toMatchObject({ status: 'removed', prev: 'x' }); |
| expect(node.children?.get('changed')).toMatchObject({ |
| status: 'modified', |
| prev: 'a', |
| value: 'b', |
| }); |
| }); |
|
|
| it('matches entity arrays by id instead of index', () => { |
| const t1 = turnMsg(1); |
| const t2 = turnMsg(2); |
| const prev = [t1, t2]; |
| const next = [t1, { ...t2, status: 'running' as const }, turnMsg(3)]; |
| const node = diffValue(prev, next); |
| expect(node.children?.get('t1')?.status).toBe('unchanged'); |
| expect(node.children?.get('t2')?.status).toBe('modified'); |
| expect(node.children?.get('t2')?.children?.get('status')).toMatchObject({ |
| status: 'modified', |
| prev: 'completed', |
| value: 'running', |
| }); |
| expect(node.children?.get('t3')?.status).toBe('added'); |
| }); |
|
|
| it('keys steps by step_id (not their shared turn_id) so siblings never collide', () => { |
| const done = stepMsg('t1.1', 'completed'); |
| const node = diffValue( |
| [done, stepMsg('t1.2', 'completed')], |
| [done, stepMsg('t1.2', 'running')], |
| ); |
| expect([...(node.children?.keys() ?? [])]).toEqual(['t1.1', 't1.2']); |
| expect(node.children?.get('t1.1')?.status).toBe('unchanged'); |
| expect(node.children?.get('t1.2')?.status).toBe('modified'); |
| }); |
|
|
| it('marks removed array elements by id', () => { |
| const t2 = turnMsg(2); |
| const node = diffValue([turnMsg(1), t2], [t2]); |
| expect(node.children?.get('t1')).toMatchObject({ status: 'removed' }); |
| expect(node.children?.get('t2')?.status).toBe('unchanged'); |
| }); |
|
|
| it('marks whole-subtree adds/removes without descending', () => { |
| const added = diffValue(undefined, { nested: { deep: 1 } }); |
| expect(added.status).toBe('added'); |
| expect(added.children).toBeUndefined(); |
| const removed = diffValue({ nested: 1 }, undefined); |
| expect(removed.status).toBe('removed'); |
| expect(removed.children).toBeUndefined(); |
| }); |
|
|
| it('treats type changes as leaf modifications', () => { |
| expect(diffValue('1', 1).status).toBe('modified'); |
| expect(diffValue(null, {}).status).toBe('modified'); |
| expect(diffValue([1], { 0: 1 }).status).toBe('modified'); |
| }); |
|
|
| it('diffs two serialized states with session.state changes visible', () => { |
| const base = stateWithTimeline([turnMsg(1)]); |
| const prev = serializeState(base); |
| const nextState: ChatState = { |
| ...base, |
| sessionState: { |
| type: 'session.state', |
| session_id: 's1', |
| timestamp: ts(), |
| status: 'running', |
| goal: { objective: 'ship it', status: 'active' }, |
| modes: { plan: { review_path: '/tmp/plan.md' } }, |
| }, |
| }; |
| const node: DiffNode = diffValue(prev, serializeState(nextState)); |
| expect(node.children?.get('timeline')?.status).toBe('unchanged'); |
| const sessionState = node.children?.get('sessionState'); |
| expect(sessionState?.status).toBe('added'); |
| expect(sessionState?.children).toBeUndefined(); |
| }); |
| }); |
|
|
| |
|
|
| describe('serializeState', () => { |
| it('turns maps into sorted plain objects and flattens the timeline', () => { |
| const state: ChatState = { |
| ...EMPTY_CHAT_STATE, |
| entries: stateWithTimeline([turnMsg(1)]).entries, |
| tasks: new Map([ |
| [ |
| 'b-task', |
| { |
| type: 'task', |
| session_id: 's1', |
| agent_id: 'main', |
| timestamp: ts(), |
| task_id: 'b-task', |
| kind: 'shell', |
| status: 'running', |
| detached: false, |
| output_tail: '', |
| }, |
| ], |
| [ |
| 'a-task', |
| { |
| type: 'task', |
| session_id: 's1', |
| agent_id: 'main', |
| timestamp: ts(), |
| task_id: 'a-task', |
| kind: 'tool', |
| status: 'completed', |
| detached: false, |
| output_tail: '', |
| }, |
| ], |
| ]), |
| }; |
| const out = serializeState(state); |
| expect(Object.keys(out.tasks)).toEqual(['a-task', 'b-task']); |
| expect(out.timeline.map((m) => (m.type === 'turn' ? m.turn_id : ''))).toEqual(['t1']); |
| expect(out.hasMoreOlder).toBe(false); |
| }); |
| }); |
|
|
| |
|
|
| describe('tailTrunc', () => { |
| it('returns short strings unchanged', () => { |
| expect(tailTrunc('hello')).toBe('hello'); |
| expect(tailTrunc('x'.repeat(500))).toBe('x'.repeat(500)); |
| }); |
|
|
| it('keeps the tail of long strings and reports the total length', () => { |
| const value = 'head-padding'.repeat(100) + 'THE-TAIL'; |
| const out = tailTrunc(value, 50); |
| expect(out).toContain(`${value.length} chars total`); |
| expect(out.endsWith('THE-TAIL')).toBe(true); |
| expect(out).not.toContain('head-padding'.repeat(10)); |
| }); |
| }); |
|
|
| |
|
|
| describe('AuditTrail', () => { |
| it('records entries with increasing indices, timestamps, and state references', () => { |
| const trail = new AuditTrail(); |
| const s1 = stateWithTimeline([turnMsg(1)]); |
| const s2 = stateWithTimeline([turnMsg(1), turnMsg(2)]); |
| trail.recordRest({ pageSize: 500 }, 'replace', 1, { turn_id: 't1', step_id: 't1.1' }, s1); |
| trail.recordWs(turnMsg(2, 'running'), s2); |
| trail.recordEvent('prompt', 'hello', s2); |
|
|
| const entries = trail.getEntries(); |
| expect(entries.map((entry) => entry.kind)).toEqual(['rest', 'ws', 'event']); |
| expect(entries.map((entry) => entry.index)).toEqual([0, 1, 2]); |
| expect(entries[0]!.state).toBe(s1); |
| expect(entries[1]!.state).toBe(s2); |
| expect(entries[0]).toMatchObject({ mode: 'replace', messageCount: 1 }); |
| expect(entries[2]).toMatchObject({ event: 'prompt', detail: 'hello' }); |
| expect(entries.every((entry) => typeof entry.at === 'string' && entry.at.length > 0)).toBe( |
| true, |
| ); |
| expect(entries.every((entry) => entry.summary.length > 0)).toBe(true); |
| }); |
|
|
| it('notifies subscribers on each record', () => { |
| const trail = new AuditTrail(); |
| let notified = 0; |
| const unsubscribe = trail.subscribe(() => { |
| notified += 1; |
| }); |
| trail.recordEvent('cancel', undefined, EMPTY_CHAT_STATE); |
| trail.recordEvent('ack', undefined, EMPTY_CHAT_STATE); |
| expect(notified).toBe(2); |
| unsubscribe(); |
| trail.recordEvent('reconnect', undefined, EMPTY_CHAT_STATE); |
| expect(notified).toBe(2); |
| }); |
|
|
| it('drops the oldest entries beyond the cap while indices keep increasing', () => { |
| const trail = new AuditTrail(); |
| for (let i = 0; i < AUDIT_TRAIL_MAX_ENTRIES + 10; i += 1) { |
| trail.recordEvent('prompt', `p${i}`, EMPTY_CHAT_STATE); |
| } |
| const entries = trail.getEntries(); |
| expect(entries).toHaveLength(AUDIT_TRAIL_MAX_ENTRIES); |
| expect(entries[0]!.index).toBe(10); |
| expect(entries.at(-1)!.index).toBe(AUDIT_TRAIL_MAX_ENTRIES + 9); |
| }); |
| }); |
|
|
