Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

6.7 KB
Raw Blame
import { describe, expect, it } from 'vitest'
import {
  CursorNormalizer,
  cursorMessagesToEvents,
  cursorTaskId,
  cursorUserText,
  lastCursorTurnText,
  windowCursorLines,
} from './normalizer.js'

const line = (value: unknown): string => JSON.stringify(value)
const user = (text: string): string => line({
  role: 'user',
  message: { content: [{ type: 'text', text: `<timestamp>now</timestamp>\n<user_query>\n${text}\n</user_query>` }] },
})
const assistant = (...content: unknown[]): string => line({ role: 'assistant', message: { content } })

describe('CursorNormalizer', () => {
  it('strips only the outer Cursor user wrapper', () => {
    expect(cursorUserText('<timestamp>x</timestamp><user_query>hello <tag>x</tag></user_query>'))
      .toBe('hello <tag>x</tag>')
  })

  it('folds TodoWrite deltas into full snapshots', () => {
    const events = cursorMessagesToEvents([
      user('todo'),
      assistant({ type: 'tool_use', name: 'TodoWrite', input: {
        merge: false,
        todos: [
          { id: 'a', content: 'A', status: 'in_progress' },
          { id: 'b', content: 'B', status: 'pending' },
        ],
      } }),
      assistant({ type: 'tool_use', name: 'TodoWrite', input: {
        merge: true,
        todos: [
          { id: 'a', status: 'completed' },
          { id: 'b', status: 'deleted' },
        ],
      } }),
      line({ type: 'turn_ended', status: 'success' }),
    ], 'session')
    const starts = events.filter((event) => event.type === 'tool_start')
    expect(starts).toHaveLength(2)
    expect(starts[1]).toMatchObject({
      payload: {
        tool: 'TodoWrite',
        input: {
          todos: [
            { id: 'a', content: 'A', status: 'completed' },
          ],
        },
      },
    })
  })

  it('normalizes Cursor WebSearch search_term to the client query field', () => {
    const events = cursorMessagesToEvents([
      user('search'),
      assistant({ type: 'tool_use', name: 'WebSearch', input: {
        search_term: 'Bitcoin BTC Ethereum ETH price USD today live',
        explanation: 'Get current prices.',
      } }),
      line({ type: 'turn_ended', status: 'success' }),
    ], 'session')

    expect(events).toContainEqual({
      type: 'tool_start',
      payload: {
        id: 'cursor:session:1:0',
        tool: 'WebSearch',
        input: {
          query: 'Bitcoin BTC Ethereum ETH price USD today live',
          search_term: 'Bitcoin BTC Ethereum ETH price USD today live',
          explanation: 'Get current prices.',
        },
      },
    })
  })

  it('hides Cursor redaction placeholders from live and replay text', () => {
    const response = assistant(
      { type: 'text', text: 'Hi - can gi tiep khong?\n\n[REDACTED]' },
      { type: 'text', text: '[REDACTED]' },
    )
    const live = new CursorNormalizer('live', 'session')
    live.ingest(user('hi'))

    expect(live.ingest(response)).toEqual([{
      type: 'text_delta',
      payload: { content: 'Hi - can gi tiep khong?' },
    }])
    expect(cursorMessagesToEvents([user('hi'), response], 'session')).toContainEqual({
      type: 'text_delta',
      payload: { content: 'Hi - can gi tiep khong?' },
    })
    expect(cursorMessagesToEvents([user('hi'), response], 'session'))
      .not.toContainEqual(expect.objectContaining({
        type: 'text_delta',
        payload: expect.objectContaining({ content: '[REDACTED]' }),
      }))
  })

  it('hides Cursor redaction placeholders from recap text', () => {
    expect(lastCursorTurnText([
      user('hi'),
      assistant({ type: 'text', text: 'Hi - can gi tiep khong?\n\n[REDACTED]' }),
      assistant({ type: 'text', text: '[REDACTED]' }),
    ])).toEqual({
      userMessage: 'hi',
      assistantText: 'Hi - can gi tiep khong?',
    })
  })

  it('deduplicates Task preToolUse from the later transcript block', () => {
    const normalizer = new CursorNormalizer('live', 'session')
    const input = { description: 'Inspect', prompt: 'Inspect it', model: 'inherit' }
    const hook = normalizer.ingestTaskHook({ toolUseId: 'call-1', input })
    const transcript = normalizer.ingest(assistant({ type: 'tool_use', name: 'Task', input }))
    expect(hook).toEqual([{
      type: 'tool_start',
      payload: { id: cursorTaskId('session', 'call-1'), tool: 'Task', input },
    }])
    expect(transcript).toEqual([])
  })

  it('maps replay child tools and result under the Task launcher', () => {
    const events = cursorMessagesToEvents([
      user('delegate'),
      assistant({ type: 'tool_use', name: 'Task', input: { description: 'Inspect', prompt: 'Inspect it' } }),
    ], 'session', [{
      toolUseId: 'call-1',
      prompt: 'Inspect it',
      output: 'Done',
      isError: false,
      agentId: 'child',
      totalToolUseCount: 1,
      events: [
        { type: 'tool_start', payload: { id: 'child-tool', tool: 'Read', input: { path: 'a' } } },
        { type: 'tool_end', payload: { id: 'child-tool', tool: 'Read', output: '', isError: false, summary: 'Completed' } },
      ],
    }])
    const launcherId = cursorTaskId('session', 'call-1')
    expect(events).toContainEqual({
      type: 'tool_start',
      payload: { id: 'child-tool', tool: 'Read', input: { path: 'a' }, parentToolUseId: launcherId },
    })
    expect(events).toContainEqual(expect.objectContaining({
      type: 'tool_end',
      payload: expect.objectContaining({ id: launcherId, output: 'Done' }),
    }))
  })

  it('hydrates Todo state before a paginated window that starts with a delta', () => {
    const lines = [
      user('first'),
      assistant({ type: 'tool_use', name: 'TodoWrite', input: {
        merge: false,
        todos: [{ id: 'a', content: 'A', status: 'pending' }],
      } }),
      line({ type: 'turn_ended', status: 'success' }),
      user('second'),
      assistant({ type: 'tool_use', name: 'TodoWrite', input: {
        merge: true,
        todos: [{ id: 'a', status: 'completed' }],
      } }),
      line({ type: 'turn_ended', status: 'success' }),
    ]
    const window = windowCursorLines(lines, { limit: 2 })
    const events = cursorMessagesToEvents(
      window.window,
      'session',
      [],
      window.startIndex,
      window.initialTodos,
    )
    expect(events).toContainEqual(expect.objectContaining({
      type: 'tool_start',
      payload: expect.objectContaining({
        tool: 'TodoWrite',
        input: { todos: [{ id: 'a', content: 'A', status: 'completed' }] },
      }),
    }))
  })

  it('emits the existing done marker before the live turn boundary', () => {
    const normalizer = new CursorNormalizer('live', 'session')
    const events = [
      ...normalizer.ingest(user('hello')),
      ...normalizer.ingest(line({ type: 'turn_ended', status: 'success' })),
    ]
    expect(events.slice(-2)).toEqual([
      { type: 'done', payload: { result: 'success' } },
      { type: 'turn_ended', payload: {} },
    ])
  })
})