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 { readFileSync } from 'fs'
import { fileURLToPath } from 'url'
import {
  isPermissionRejection,
  kiloMessagesToEvents,
  kiloToolName,
  lastKiloTurnText,
  windowKiloMessages,
  type KiloMessage,
} from './normalizer.js'

/**
 * A REAL kilo 7.4.20 session, exported from this machine's own `kilo.db` with the home directory
 * scrubbed. Two turns were driven by hand in a tmux pane: one that read a file and wrote a todo list,
 * and one whose file read was REFUSED at kilo's permission prompt. Nothing here is hand-written, which
 * is the point — every tool id and field name below is what kilo actually stored.
 */
function session(): KiloMessage[] {
  const p = fileURLToPath(new URL('../../lib/__fixtures__/kilo-session.json', import.meta.url))
  return JSON.parse(readFileSync(p, 'utf-8')) as KiloMessage[]
}

describe('kilo normalizer — replay', () => {
  it('renders the measured session as a conversation', () => {
    const events = kiloMessagesToEvents(session())
    expect(events.map((e) => e.type)).toEqual([
      'user_message',
      'thinking_delta', 'tool_start', 'tool_end',
      'thinking_delta', 'tool_start', 'tool_end',
      'thinking_delta', 'text_delta',
      'user_message',
      'thinking_delta', 'tool_start', 'tool_end',
      'done',
    ])
    expect(events[0]).toMatchObject({ payload: { content: expect.stringContaining('read notes.txt') } })
  })

  /**
   * ONE user message produced THREE assistant messages here. Replay must not invent a turn boundary
   * between them — the conversation is one exchange, and the reader (not this path) owns turn frames.
   */
  it('replays as a conversation, not as a turn lifecycle', () => {
    // ONE user message produced THREE assistant messages here, and replay must not invent boundaries
    // between them. The replay type has no turn frames at all — that asserting one does not even
    // typecheck is the real guarantee; this checks the count the surfaces actually render.
    const events = kiloMessagesToEvents(session())
    expect(events.filter((e) => e.type === 'user_message')).toHaveLength(2)
    expect(events[events.length - 1]).toMatchObject({ type: 'done' })
  })

  it('maps the measured tool ids onto the shared vocabulary', () => {
    const events = kiloMessagesToEvents(session())
    const tools = events.filter((e) => e.type === 'tool_start')
      .map((e) => (e as { payload: { tool: string } }).payload.tool)
    // `read` and `todowrite` are what kilo actually called — not names borrowed from another engine.
    expect(tools).toEqual(['Read', 'TodoWrite', 'Read'])
  })

  /**
   * The device checklist reads `input.todos[].content` literally. Kilo already speaks that shape, so the
   * assertion here is that nothing reshapes it away — a rename would empty the checklist with no error.
   */
  it("hands the checklist kilo's todos under the field the device reads", () => {
    const start = kiloMessagesToEvents(session())
      .find((e) => e.type === 'tool_start' && (e as { payload: { tool: string } }).payload.tool === 'TodoWrite')
    const input = (start as { payload: { input: { todos: Array<{ content: string; status: string }> } } }).payload.input
    expect(input.todos).toHaveLength(3)
    expect(input.todos[0].content).toBe('Review and organize files in /private/tmp/kilo-probe')
    expect(input.todos[0].status).toBe('pending')
  })

  it('marks the refused tool as an error rather than a silent success', () => {
    const ends = kiloMessagesToEvents(session()).filter((e) => e.type === 'tool_end')
    const last = ends[ends.length - 1] as { payload: { isError: boolean; output: string } }
    expect(last.payload.isError).toBe(true)
    expect(last.payload.output).toContain('rejected permission')
  })
})

/**
 * The refusal is a turn BOUNDARY, and it is the one kilo never writes a `step-finish reason:'stop'` for.
 * These two cases are what stop a refused turn from spinning the device tile forever.
 */
describe('kilo permission refusal', () => {
  it('recognises the refusal kilo actually wrote', () => {
    const refused = session()[5].parts.find((p) => p.type === 'tool')!
    expect(isPermissionRejection(refused)).toBe(true)
  })

  it('does NOT treat an ordinary tool failure as the end of a turn', () => {
    // A failing command is handed back to the model and it carries on; closing here would cut turns off
    // mid-flight. Only a refusal stops kilo.
    expect(isPermissionRejection({
      id: 'prt_x',
      type: 'tool',
      data: { type: 'tool', tool: 'bash', state: { status: 'error', error: 'command not found: frobnicate' } },
    })).toBe(false)
    expect(isPermissionRejection({
      id: 'prt_y', type: 'text', data: { type: 'text', text: 'rejected permission' },
    })).toBe(false)
  })
})

describe('kilo recap source', () => {
  it('reads the last prompt and the answer that followed it', () => {
    // Drop the refused exchange: this is the last turn that actually answered.
    const answered = session().slice(0, 4)
    const last = lastKiloTurnText(answered)
    expect(last?.userMessage).toContain('read notes.txt')
    expect(last?.assistantText).toContain('alpha')
  })

  /**
   * Measured, and deliberate: the refused turn produced no assistant text, and the recap reports NOTHING
   * rather than re-summarising the previous turn. A recap sourced from the wrong turn is the classic
   * symptom of a last-turn tracker resetting on the wrong record, so an empty answer is the honest one.
   */
  it('reports nothing when the last turn was refused and said nothing', () => {
    expect(lastKiloTurnText(session())).toBeNull()
  })

  it('reports nothing for a session with no assistant text at all', () => {
    expect(lastKiloTurnText([])).toBeNull()
  })
})

describe('kilo history window', () => {
  it('namespaces its cursor so another engine cannot index into it', () => {
    const w = windowKiloMessages(session(), { limit: 2 })
    expect(w.oldestCursor).toMatch(/^kilo:\d+$/)
    expect(w.hasMore).toBe(true)
    // An opencode cursor is not a kilo cursor, even though the two stores are shaped the same.
    expect(windowKiloMessages(session(), { limit: 2, before: 'opencode:3' }).staleCursor).toBe(true)
  })

  it('snaps the window back to a user message so a turn is never split', () => {
    const w = windowKiloMessages(session(), { limit: 2 })
    expect(w.window[0].role).toBe('user')
  })
})

describe('kilo tool names', () => {
  it('title-cases an id it has never seen instead of guessing at it', () => {
    // The measured ids are asserted above. An unmeasured one must render plainly rather than land on
    // some other engine's card by accident.
    expect(kiloToolName('frobnicate')).toBe('Frobnicate')
    expect(kiloToolName('')).toBe('tool')
  })
})