@alumbwe/anvil 1.0.42 → 1.0.49

package/src/hooks/__tests__/use-queue-ui.test.tsx

@@ -1,83 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { createTestRenderer } from '@opentui/core/testing'
-import { createRoot, flushSync } from '@opentui/react'
-import React from 'react'
-
-import { useQueueUi } from '../use-queue-ui'
-
-import type { QueuedMessage } from '../use-message-queue'
-
-const message = (content: string): QueuedMessage => ({
-  id: content,
-  content,
-  attachments: [],
-})
-
-/** Renders the hook's title so the branches can be read off one string. */
-const titleFor = async (params: {
-  queuePaused: boolean
-  queuedMessages: QueuedMessage[]
-  terminalWidth: number
-}) => {
-  let title: string | undefined
-  const Harness = () => {
-    title = useQueueUi({ ...params, separatorWidth: params.terminalWidth })
-      .inputBoxTitle
-    return <text>x</text>
-  }
-
-  const setup = await createTestRenderer({ width: 20, height: 2 })
-  const root = createRoot(setup.renderer)
-  flushSync(() => root.render(<Harness />))
-  await setup.renderOnce()
-  flushSync(() => root.unmount())
-  setup.renderer.destroy()
-  return title
-}
-
-describe('useQueueUi inputBoxTitle', () => {
-  test('is absent with an empty queue', async () => {
-    expect(
-      await titleFor({
-        queuePaused: false,
-        queuedMessages: [],
-        terminalWidth: 100,
-      }),
-    ).toBeUndefined()
-  })
-
-  test('previews the latest queued message and advertises mouse expansion', async () => {
-    const title = await titleFor({
-      queuePaused: false,
-      queuedMessages: [message('first task'), message('second task')],
-      terminalWidth: 100,
-    })
-
-    expect(title).toContain('second task')
-    expect(title).toContain('(+ 1)')
-    expect(title).toContain('▸')
-    expect(title).toContain('click to expand')
-  })
-
-  test('drops the hint on a narrow terminal rather than crowd the preview', async () => {
-    const title = await titleFor({
-      queuePaused: false,
-      queuedMessages: [message('first task')],
-      terminalWidth: 70,
-    })
-
-    expect(title).toContain('first task')
-    expect(title).not.toContain('click to expand')
-  })
-
-  test('a paused queue says so, and is still editable', async () => {
-    const title = await titleFor({
-      queuePaused: true,
-      queuedMessages: [message('first task')],
-      terminalWidth: 100,
-    })
-
-    expect(title).toContain('⏸ 1 message queued')
-    expect(title).toContain('click to expand')
-  })
-})

package/src/hooks/__tests__/use-searchable-list.test.ts

@@ -1,359 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-
-/**
- * Tests for useSearchableList hook logic.
- *
- * These tests focus on the pure logic aspects of the hook:
- * - Default filter function: case-insensitive label matching
- * - Focus index clamping logic
- * - Filtering behavior
- */
-
-interface TestItem {
-  id: string
-  label: string
-}
-
-// Extract the default filter function for testing
-const defaultFilterFn = (item: TestItem, query: string): boolean =>
-  item.label.toLowerCase().includes(query.toLowerCase())
-
-// Extract the filter logic for testing
-const filterItems = <T extends TestItem>(
-  items: T[],
-  query: string,
-  filterFn: (item: T, query: string) => boolean = defaultFilterFn,
-): T[] => {
-  if (!query.trim()) return items
-  return items.filter((item) => filterFn(item, query))
-}
-
-// Extract the focus index clamping logic for testing
-const clampFocusIndex = (focusedIndex: number, listLength: number): number => {
-  if (focusedIndex >= listLength) {
-    return Math.max(0, listLength - 1)
-  }
-  return focusedIndex
-}
-
-describe('useSearchableList - defaultFilterFn', () => {
-  describe('case-insensitive matching', () => {
-    test('matches exact case', () => {
-      const item = { id: '1', label: 'Documents' }
-      expect(defaultFilterFn(item, 'Documents')).toBe(true)
-    })
-
-    test('matches lowercase query against mixed case label', () => {
-      const item = { id: '1', label: 'Documents' }
-      expect(defaultFilterFn(item, 'documents')).toBe(true)
-    })
-
-    test('matches uppercase query against lowercase label', () => {
-      const item = { id: '1', label: 'documents' }
-      expect(defaultFilterFn(item, 'DOCUMENTS')).toBe(true)
-    })
-
-    test('matches mixed case query against mixed case label', () => {
-      const item = { id: '1', label: 'MyDocuments' }
-      expect(defaultFilterFn(item, 'mydocuments')).toBe(true)
-    })
-  })
-
-  describe('substring matching', () => {
-    test('matches substring at start', () => {
-      const item = { id: '1', label: 'Documents' }
-      expect(defaultFilterFn(item, 'Doc')).toBe(true)
-    })
-
-    test('matches substring in middle', () => {
-      const item = { id: '1', label: 'Documents' }
-      expect(defaultFilterFn(item, 'umen')).toBe(true)
-    })
-
-    test('matches substring at end', () => {
-      const item = { id: '1', label: 'Documents' }
-      expect(defaultFilterFn(item, 'ments')).toBe(true)
-    })
-
-    test('matches single character', () => {
-      const item = { id: '1', label: 'Documents' }
-      expect(defaultFilterFn(item, 'o')).toBe(true)
-    })
-
-    test('matches full label', () => {
-      const item = { id: '1', label: 'Documents' }
-      expect(defaultFilterFn(item, 'Documents')).toBe(true)
-    })
-  })
-
-  describe('non-matching cases', () => {
-    test('does not match when query is not in label', () => {
-      const item = { id: '1', label: 'Documents' }
-      expect(defaultFilterFn(item, 'xyz')).toBe(false)
-    })
-
-    test('does not match partial word boundaries', () => {
-      const item = { id: '1', label: 'test' }
-      expect(defaultFilterFn(item, 'testing')).toBe(false)
-    })
-
-    test('does not match reversed substring', () => {
-      const item = { id: '1', label: 'Documents' }
-      expect(defaultFilterFn(item, 'tnemucod')).toBe(false)
-    })
-  })
-
-  describe('edge cases', () => {
-    test('empty query matches everything (via includes behavior)', () => {
-      const item = { id: '1', label: 'Documents' }
-      expect(defaultFilterFn(item, '')).toBe(true)
-    })
-
-    test('handles empty label', () => {
-      const item = { id: '1', label: '' }
-      expect(defaultFilterFn(item, 'test')).toBe(false)
-    })
-
-    test('empty query matches empty label', () => {
-      const item = { id: '1', label: '' }
-      expect(defaultFilterFn(item, '')).toBe(true)
-    })
-
-    test('handles special characters in label', () => {
-      const item = { id: '1', label: 'my-project_v2.0' }
-      expect(defaultFilterFn(item, 'project_v2')).toBe(true)
-    })
-
-    test('handles special characters in query', () => {
-      const item = { id: '1', label: 'my-project_v2.0' }
-      expect(defaultFilterFn(item, '-project_')).toBe(true)
-    })
-
-    test('handles spaces in label', () => {
-      const item = { id: '1', label: 'My Documents Folder' }
-      expect(defaultFilterFn(item, 'documents folder')).toBe(true)
-    })
-
-    test('handles unicode characters', () => {
-      const item = { id: '1', label: 'Документы' }
-      expect(defaultFilterFn(item, 'докум')).toBe(true)
-    })
-  })
-})
-
-describe('useSearchableList - filterItems', () => {
-  const testItems: TestItem[] = [
-    { id: '1', label: 'Documents' },
-    { id: '2', label: 'Downloads' },
-    { id: '3', label: 'Desktop' },
-    { id: '4', label: 'Music' },
-    { id: '5', label: 'Pictures' },
-  ]
-
-  describe('empty query behavior', () => {
-    test('returns all items when query is empty', () => {
-      const result = filterItems(testItems, '')
-      expect(result).toEqual(testItems)
-    })
-
-    test('returns all items when query is whitespace only', () => {
-      const result = filterItems(testItems, '   ')
-      expect(result).toEqual(testItems)
-    })
-
-    test('returns all items when query is tabs and newlines', () => {
-      const result = filterItems(testItems, '\t\n')
-      expect(result).toEqual(testItems)
-    })
-  })
-
-  describe('filtering behavior', () => {
-    test('filters to matching items', () => {
-      const result = filterItems(testItems, 'Do')
-      expect(result).toHaveLength(2)
-      expect(result.map((i) => i.label)).toEqual(['Documents', 'Downloads'])
-    })
-
-    test('filters to single matching item', () => {
-      const result = filterItems(testItems, 'Music')
-      expect(result).toHaveLength(1)
-      expect(result[0].label).toBe('Music')
-    })
-
-    test('returns empty array when nothing matches', () => {
-      const result = filterItems(testItems, 'xyz')
-      expect(result).toHaveLength(0)
-    })
-
-    test('preserves original order', () => {
-      const result = filterItems(testItems, 'D')
-      expect(result.map((i) => i.label)).toEqual([
-        'Documents',
-        'Downloads',
-        'Desktop',
-      ])
-    })
-  })
-
-  describe('custom filter function', () => {
-    test('uses custom filter function when provided', () => {
-      const customFilter = (item: TestItem, query: string) =>
-        item.label.startsWith(query)
-      const result = filterItems(testItems, 'D', customFilter)
-      expect(result.map((i) => i.label)).toEqual([
-        'Documents',
-        'Downloads',
-        'Desktop',
-      ])
-    })
-
-    test('custom filter can match by id', () => {
-      const idFilter = (item: TestItem, query: string) => item.id === query
-      const result = filterItems(testItems, '3', idFilter)
-      expect(result).toHaveLength(1)
-      expect(result[0].label).toBe('Desktop')
-    })
-
-    test('custom filter can implement exact match', () => {
-      const exactFilter = (item: TestItem, query: string) =>
-        item.label.toLowerCase() === query.toLowerCase()
-      const result = filterItems(testItems, 'music', exactFilter)
-      expect(result).toHaveLength(1)
-      expect(result[0].label).toBe('Music')
-    })
-  })
-
-  describe('edge cases', () => {
-    test('handles empty items array', () => {
-      const result = filterItems([], 'test')
-      expect(result).toEqual([])
-    })
-
-    test('handles single item array', () => {
-      const single = [{ id: '1', label: 'Test' }]
-      const result = filterItems(single, 'Test')
-      expect(result).toEqual(single)
-    })
-
-    test('does not mutate original array', () => {
-      const original = [...testItems]
-      filterItems(testItems, 'Do')
-      expect(testItems).toEqual(original)
-    })
-  })
-})
-
-describe('useSearchableList - clampFocusIndex', () => {
-  describe('when index is within bounds', () => {
-    test('returns index unchanged when within bounds', () => {
-      expect(clampFocusIndex(2, 5)).toBe(2)
-    })
-
-    test('returns 0 when index is 0 and list has items', () => {
-      expect(clampFocusIndex(0, 5)).toBe(0)
-    })
-
-    test('returns last index when at last position', () => {
-      expect(clampFocusIndex(4, 5)).toBe(4)
-    })
-  })
-
-  describe('when index exceeds bounds', () => {
-    test('clamps to last index when focusedIndex equals length', () => {
-      expect(clampFocusIndex(5, 5)).toBe(4)
-    })
-
-    test('clamps to last index when focusedIndex exceeds length', () => {
-      expect(clampFocusIndex(10, 5)).toBe(4)
-    })
-
-    test('clamps to 0 when list becomes empty', () => {
-      expect(clampFocusIndex(5, 0)).toBe(0)
-    })
-
-    test('clamps to 0 when focusedIndex is large and list is empty', () => {
-      expect(clampFocusIndex(100, 0)).toBe(0)
-    })
-  })
-
-  describe('single item list', () => {
-    test('returns 0 for single item list when index is 0', () => {
-      expect(clampFocusIndex(0, 1)).toBe(0)
-    })
-
-    test('clamps to 0 for single item list when index exceeds', () => {
-      expect(clampFocusIndex(5, 1)).toBe(0)
-    })
-  })
-
-  describe('edge cases', () => {
-    test('handles negative index (returns as-is since not >= length)', () => {
-      // The clamping logic only handles index >= length
-      // Negative indices are returned unchanged
-      expect(clampFocusIndex(-1, 5)).toBe(-1)
-    })
-
-    test('handles very large list length', () => {
-      expect(clampFocusIndex(999, 1000)).toBe(999)
-      expect(clampFocusIndex(1000, 1000)).toBe(999)
-    })
-  })
-})
-
-describe('useSearchableList - integration scenarios', () => {
-  const items: TestItem[] = [
-    { id: '1', label: 'alpha' },
-    { id: '2', label: 'beta' },
-    { id: '3', label: 'gamma' },
-    { id: '4', label: 'delta' },
-    { id: '5', label: 'epsilon' },
-  ]
-
-  test('scenario: filter reduces list and clamp adjusts index', () => {
-    // Start with focusedIndex = 4 (epsilon)
-    let focusedIndex = 4
-    
-    // Filter to items containing 'a' -> [alpha, beta, gamma, delta] (beta contains 'a')
-    const filtered = filterItems(items, 'a')
-    expect(filtered).toHaveLength(4)
-    
-    // Clamp the focus index
-    focusedIndex = clampFocusIndex(focusedIndex, filtered.length)
-    expect(focusedIndex).toBe(3) // Clamped to last index (4-1=3)
-  })
-
-  test('scenario: filter to empty list clamps to 0', () => {
-    let focusedIndex = 2
-    
-    const filtered = filterItems(items, 'xyz')
-    expect(filtered).toHaveLength(0)
-    
-    focusedIndex = clampFocusIndex(focusedIndex, filtered.length)
-    expect(focusedIndex).toBe(0)
-  })
-
-  test('scenario: clearing filter restores full list', () => {
-    // First filter - 'a' matches alpha, beta, gamma, delta
-    let filtered = filterItems(items, 'a')
-    expect(filtered).toHaveLength(4)
-    
-    // Clear filter
-    filtered = filterItems(items, '')
-    expect(filtered).toHaveLength(5)
-    expect(filtered).toEqual(items)
-  })
-
-  test('scenario: progressive filtering narrows results', () => {
-    // 'a' matches alpha, beta, gamma, delta (all contain 'a')
-    let filtered = filterItems(items, 'a')
-    expect(filtered.map((i) => i.label)).toEqual(['alpha', 'beta', 'gamma', 'delta'])
-    
-    // 'al' only matches alpha
-    filtered = filterItems(items, 'al')
-    expect(filtered.map((i) => i.label)).toEqual(['alpha'])
-    
-    // 'alp' still only matches alpha
-    filtered = filterItems(items, 'alp')
-    expect(filtered.map((i) => i.label)).toEqual(['alpha'])
-  })
-})

package/src/hooks/__tests__/use-send-message-timer.test.ts

@@ -1,146 +0,0 @@
-import { describe, test, expect, beforeEach, mock } from 'bun:test'
-
-import {
-  createSendMessageTimerController,
-  type SendMessageTimerEvent,
-  type SendMessageTimerOutcome,
-} from '../../utils/send-message-timer'
-
-import type { ElapsedTimeTracker } from '../use-elapsed-time'
-
-describe('createSendMessageTimerController', () => {
-  let mainAgentTimer: ElapsedTimeTracker
-  let timerEvents: SendMessageTimerEvent[]
-  let startMock: ReturnType<typeof mock>
-  let stopMock: ReturnType<typeof mock>
-  let nowValues: number[]
-
-  const createController = (agentId?: string, nowOverride?: () => number) =>
-    createSendMessageTimerController({
-      mainAgentTimer,
-      agentId,
-      onTimerEvent: (event) => timerEvents.push(event),
-      now: nowOverride ?? (() => Date.now()),
-    })
-
-  beforeEach(() => {
-    timerEvents = []
-    nowValues = []
-    startMock = mock(() => {})
-    stopMock = mock(() => {})
-    mainAgentTimer = {
-      start: startMock,
-      stop: stopMock,
-      pause: mock(() => {}),
-      resume: mock(() => {}),
-      elapsedSeconds: 0,
-      startTime: null,
-      isPaused: false,
-    }
-  })
-
-  const nextNow = () => {
-    if (nowValues.length === 0) {
-      throw new Error('No mock time available')
-    }
-    return nowValues.shift()!
-  }
-
-  test('emits start and stop events with elapsed time', () => {
-    nowValues = [1_000, 1_640]
-    const controller = createController('assistant', nextNow)
-
-    controller.start('ai-123')
-    const result = controller.stop('success')
-
-    expect(result?.elapsedMs).toBe(640)
-    expect(result?.finishedAt).toBe(1_640)
-    expect(startMock.mock.calls.length).toBe(1)
-    expect(stopMock.mock.calls.length).toBe(1)
-    expect(timerEvents.map((event) => event.type)).toEqual(['start', 'stop'])
-
-    const startEvent = timerEvents[0] as Extract<
-      SendMessageTimerEvent,
-      { type: 'start' }
-    >
-    const stopEvent = timerEvents[1] as Extract<
-      SendMessageTimerEvent,
-      { type: 'stop' }
-    >
-
-    expect(startEvent.startedAt).toBe(1_000)
-    expect(startEvent.agentId).toBe('assistant')
-    expect(startEvent.messageId).toBe('ai-123')
-
-    expect(stopEvent.startedAt).toBe(1_000)
-    expect(stopEvent.finishedAt).toBe(1_640)
-    expect(stopEvent.elapsedMs).toBe(640)
-    expect(stopEvent.outcome).toBe('success')
-    expect(stopEvent.agentId).toBe('assistant')
-    expect(stopEvent.messageId).toBe('ai-123')
-  })
-
-  test('start is idempotent until stop is called', () => {
-    const controller = createController(undefined, nextNow)
-    nowValues = [100]
-
-    controller.start('ai-1')
-    controller.start('ai-2') // should be ignored
-
-    expect(startMock.mock.calls.length).toBe(1)
-    expect(timerEvents).toHaveLength(1)
-    expect(
-      (timerEvents[0] as Extract<SendMessageTimerEvent, { type: 'start' }>)
-        .messageId,
-    ).toBe('ai-1')
-  })
-
-  test('stop returns null when timer was never started', () => {
-    const controller = createController()
-
-    const result = controller.stop('error')
-
-    expect(result).toBeNull()
-    expect(stopMock.mock.calls.length).toBe(0)
-    expect(timerEvents).toHaveLength(0)
-  })
-
-  test('records outcome-specific stop events', () => {
-    const outcomes: SendMessageTimerOutcome[] = ['success', 'error', 'aborted']
-    nowValues = [10, 20, 30, 40, 50, 60]
-    const controller = createController('assistant', nextNow)
-
-    for (const outcome of outcomes) {
-      controller.start(`ai-${outcome}`)
-      controller.stop(outcome)
-    }
-
-    const stopEvents = timerEvents.filter(
-      (event): event is Extract<SendMessageTimerEvent, { type: 'stop' }> =>
-        event.type === 'stop',
-    )
-
-    expect(stopEvents).toHaveLength(3)
-    expect(stopEvents.map((event) => event.outcome)).toEqual(outcomes)
-    expect(startMock.mock.calls.length).toBe(3)
-    expect(stopMock.mock.calls.length).toBe(3)
-  })
-
-  test('allows restarting after stop', () => {
-    nowValues = [1, 2, 3, 7]
-    const controller = createController(undefined, nextNow)
-
-    controller.start('ai-1')
-    controller.stop('success')
-    controller.start('ai-2')
-    const result = controller.stop('success')
-
-    expect(result?.elapsedMs).toBe(4)
-    const stopEvents = timerEvents.filter(
-      (event): event is Extract<SendMessageTimerEvent, { type: 'stop' }> =>
-        event.type === 'stop',
-    )
-    expect(stopEvents).toHaveLength(2)
-    expect(stopEvents[1].messageId).toBe('ai-2')
-  })
-})