@alumbwe/anvil 1.0.0

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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,359 @@
+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

@@ -0,0 +1,146 @@
+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')
+  })
+})