@alumbwe/anvil 1.0.42 → 1.0.50

package/src/hooks/__tests__/use-ask-user-bridge.test.ts

@@ -1,176 +0,0 @@
-import { AskUserBridge } from '@anvil/common/utils/ask-user-bridge'
-import { describe, test, expect, beforeEach, afterEach, spyOn } from 'bun:test'
-
-
-import { useChatStore } from '../../state/chat-store'
-
-describe('useAskUserBridge', () => {
-  const submitAnswers = (
-    answers: Array<{
-      questionIndex: number
-      selectedOption?: string
-      selectedOptions?: string[]
-      otherText?: string
-    }>
-  ) => {
-    AskUserBridge.submit({ answers })
-  }
-
-  const skip = () => {
-    AskUserBridge.submit({ skipped: true })
-  }
-
-  let submitSpy: ReturnType<typeof spyOn>
-
-  beforeEach(() => {
-    // Mock AskUserBridge.submit to track calls
-    submitSpy = spyOn(AskUserBridge, 'submit')
-
-    // Reset the chat store to a known state with some input
-    useChatStore.setState({
-      inputValue: 'user input that should be preserved',
-      cursorPosition: 35,
-      lastEditDueToNav: false,
-      askUserState: null,
-    })
-  })
-
-  afterEach(() => {
-    submitSpy.mockRestore()
-  })
-
-  describe('submitAnswers', () => {
-    test('calls AskUserBridge.submit with the provided answers', () => {
-      const answers = [
-        { questionIndex: 0, selectedOption: 'Option A' },
-        { questionIndex: 1, selectedOptions: ['Option B', 'Option C'] },
-      ]
-
-      submitAnswers(answers)
-
-      expect(submitSpy).toHaveBeenCalledTimes(1)
-      expect(submitSpy).toHaveBeenCalledWith({ answers })
-    })
-
-    test('does NOT modify the input value in the store', () => {
-      const originalInputValue = useChatStore.getState().inputValue
-      const originalCursorPosition = useChatStore.getState().cursorPosition
-
-      submitAnswers([{ questionIndex: 0, selectedOption: 'Test' }])
-
-      // Verify input value was NOT changed
-      const currentState = useChatStore.getState()
-      expect(currentState.inputValue).toBe(originalInputValue)
-      expect(currentState.cursorPosition).toBe(originalCursorPosition)
-    })
-
-    test('preserves input value with empty answers array', () => {
-      const originalInputValue = useChatStore.getState().inputValue
-
-      submitAnswers([])
-
-      expect(useChatStore.getState().inputValue).toBe(originalInputValue)
-      expect(submitSpy).toHaveBeenCalledWith({ answers: [] })
-    })
-
-    test('preserves input value with multiple question answers', () => {
-      const originalInputValue = useChatStore.getState().inputValue
-
-      const answers = [
-        { questionIndex: 0, selectedOption: 'First answer' },
-        { questionIndex: 1, selectedOptions: ['Multi 1', 'Multi 2'] },
-        { questionIndex: 2, otherText: 'Custom text input' },
-      ]
-
-      submitAnswers(answers)
-
-      expect(useChatStore.getState().inputValue).toBe(originalInputValue)
-    })
-  })
-
-  describe('skip', () => {
-    test('calls AskUserBridge.submit with skipped: true', () => {
-      skip()
-
-      expect(submitSpy).toHaveBeenCalledTimes(1)
-      expect(submitSpy).toHaveBeenCalledWith({ skipped: true })
-    })
-
-    test('does NOT modify the input value in the store', () => {
-      const originalInputValue = useChatStore.getState().inputValue
-      const originalCursorPosition = useChatStore.getState().cursorPosition
-
-      skip()
-
-      // Verify input value was NOT changed
-      const currentState = useChatStore.getState()
-      expect(currentState.inputValue).toBe(originalInputValue)
-      expect(currentState.cursorPosition).toBe(originalCursorPosition)
-    })
-  })
-
-  describe('input preservation regression tests', () => {
-    test('input with special characters is preserved after submitAnswers', () => {
-      useChatStore.setState({
-        inputValue: 'Input with "quotes" and `backticks` and @mentions',
-        cursorPosition: 48,
-      })
-
-      const originalInputValue = useChatStore.getState().inputValue
-
-      submitAnswers([{ questionIndex: 0, selectedOption: 'Test' }])
-
-      expect(useChatStore.getState().inputValue).toBe(originalInputValue)
-    })
-
-    test('input with special characters is preserved after skip', () => {
-      useChatStore.setState({
-        inputValue: "Don't lose this apostrophe or @file-picker mention",
-        cursorPosition: 51,
-      })
-
-      const originalInputValue = useChatStore.getState().inputValue
-
-      skip()
-
-      expect(useChatStore.getState().inputValue).toBe(originalInputValue)
-    })
-
-    test('multiline input is preserved after submitAnswers', () => {
-      useChatStore.setState({
-        inputValue: 'Line 1\nLine 2\nLine 3',
-        cursorPosition: 20,
-      })
-
-      const originalInputValue = useChatStore.getState().inputValue
-
-      submitAnswers([{ questionIndex: 0, selectedOption: 'Test' }])
-
-      expect(useChatStore.getState().inputValue).toBe(originalInputValue)
-    })
-
-    test('empty input remains empty after submitAnswers', () => {
-      useChatStore.setState({
-        inputValue: '',
-        cursorPosition: 0,
-      })
-
-      submitAnswers([{ questionIndex: 0, selectedOption: 'Test' }])
-
-      expect(useChatStore.getState().inputValue).toBe('')
-      expect(useChatStore.getState().cursorPosition).toBe(0)
-    })
-
-    test('empty input remains empty after skip', () => {
-      useChatStore.setState({
-        inputValue: '',
-        cursorPosition: 0,
-      })
-
-      skip()
-
-      expect(useChatStore.getState().inputValue).toBe('')
-      expect(useChatStore.getState().cursorPosition).toBe(0)
-    })
-  })
-})

package/src/hooks/__tests__/use-auth-query.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-
-import { authQueryKeys } from '../use-auth-query'
-
-describe('authQueryKeys.validation', () => {
-  test('changes when api key changes', () => {
-    const firstKey = authQueryKeys.validation('token-1')
-    const secondKey = authQueryKeys.validation('token-2')
-
-    expect(firstKey).not.toEqual(secondKey)
-  })
-
-  test('does not include the raw api key', () => {
-    const token = 'secret-token-123'
-    const key = authQueryKeys.validation(token)
-    const [, , apiKeyHash] = key
-
-    expect(key).not.toContain(token)
-    expect(apiKeyHash).toMatch(/^[0-9a-f]{64}$/)
-  })
-})

package/src/hooks/__tests__/use-chat-input-remount.test.tsx

@@ -1,66 +0,0 @@
-import { expect, test } from 'bun:test'
-import { createTestRenderer } from '@opentui/core/testing'
-import { createRoot, flushSync } from '@opentui/react'
-import React, { useCallback, useRef, useState } from 'react'
-
-import { useChatInput } from '../use-chat-input'
-
-test('initial prompt is submitted only once across Chat remounts', async () => {
-  const submissions: string[] = []
-  let setShowHistory: ((show: boolean) => void) | undefined
-
-  const ChatView = ({
-    consumeInitialPrompt,
-  }: {
-    consumeInitialPrompt: () => string | null
-  }) => {
-    useChatInput({
-      setInputValue: () => {},
-      agentMode: 'DEFAULT',
-      setAgentMode: () => {},
-      separatorWidth: 80,
-      consumeInitialPrompt,
-      onSubmitPrompt: (content) => {
-        submissions.push(content)
-      },
-      isCompactHeight: false,
-      isNarrowWidth: false,
-    })
-    return <text>chat</text>
-  }
-
-  const AppLifetime = () => {
-    const initialPromptConsumedRef = useRef(false)
-    const consumeInitialPrompt = useCallback(() => {
-      if (initialPromptConsumedRef.current) return null
-      initialPromptConsumedRef.current = true
-      return 'launch prompt'
-    }, [])
-    const [showHistory, setHistory] = useState(false)
-    setShowHistory = setHistory
-
-    return showHistory ? (
-      <text>history</text>
-    ) : (
-      <ChatView consumeInitialPrompt={consumeInitialPrompt} />
-    )
-  }
-
-  const setup = await createTestRenderer({ width: 80, height: 3 })
-  const root = createRoot(setup.renderer)
-
-  try {
-    flushSync(() => root.render(<AppLifetime />))
-    await new Promise((resolve) => setTimeout(resolve, 120))
-    expect(submissions).toEqual(['launch prompt'])
-
-    flushSync(() => setShowHistory!(true))
-    flushSync(() => setShowHistory!(false))
-    await new Promise((resolve) => setTimeout(resolve, 120))
-
-    expect(submissions).toEqual(['launch prompt'])
-  } finally {
-    flushSync(() => root.unmount())
-    setup.renderer.destroy()
-  }
-})

package/src/hooks/__tests__/use-clipboard.test.tsx

@@ -1,73 +0,0 @@
-import { createTestRenderer } from '@opentui/core/testing'
-import { createRoot, flushSync } from '@opentui/react'
-import { afterEach, describe, expect, spyOn, test } from 'bun:test'
-import React from 'react'
-
-import { useClipboard } from '../use-clipboard'
-import * as clipboard from '../../utils/clipboard'
-
-import type { CopyToClipboardOptions } from '../../utils/clipboard'
-
-const waitForSelectionCopy = () =>
-  new Promise((resolve) => setTimeout(resolve, 300))
-
-describe('useClipboard selection copying', () => {
-  let dispose: (() => void) | undefined
-
-  afterEach(() => {
-    dispose?.()
-    dispose = undefined
-  })
-
-  test('a newer selection aborts the in-flight copy before starting its own', async () => {
-    const calls: Array<{
-      text: string
-      signal: AbortSignal
-      resolve: () => void
-    }> = []
-    const copySpy = spyOn(clipboard, 'copyTextToClipboard').mockImplementation(
-      (text: string, options: CopyToClipboardOptions = {}) =>
-        new Promise<void>((resolve, reject) => {
-          const signal = options.signal!
-          signal.addEventListener('abort', () => reject(signal.reason), {
-            once: true,
-          })
-          calls.push({ text, signal, resolve })
-        }),
-    )
-
-    const Harness = () => {
-      useClipboard()
-      return <text>clipboard</text>
-    }
-    const setup = await createTestRenderer({ width: 20, height: 2 })
-    const root = createRoot(setup.renderer)
-    flushSync(() => root.render(<Harness />))
-    await setup.renderOnce()
-    dispose = () => {
-      copySpy.mockRestore()
-      flushSync(() => root.unmount())
-      setup.renderer.destroy()
-    }
-
-    setup.renderer.emit('selection', {
-      getSelectedText: () => 'first selection',
-    } as never)
-    await waitForSelectionCopy()
-    expect(calls).toHaveLength(1)
-    expect(calls[0]?.signal.aborted).toBe(false)
-
-    setup.renderer.emit('selection', {
-      getSelectedText: () => 'second selection',
-    } as never)
-    expect(calls[0]?.signal.aborted).toBe(true)
-    await waitForSelectionCopy()
-
-    expect(calls.map(({ text }) => text)).toEqual([
-      'first selection',
-      'second selection',
-    ])
-    expect(calls[1]?.signal.aborted).toBe(false)
-    calls[1]?.resolve()
-  })
-})

package/src/hooks/__tests__/use-connection-status.test.ts

@@ -1,112 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-
-import { getNextInterval } from '../use-connection-status'
-
-/**
- * Tests for the adaptive health check interval logic.
- *
- * These tests verify the core exponential backoff algorithm that determines
- * how frequently health checks should run based on consecutive successful checks.
- */
-
-describe('useConnectionStatus - adaptive interval logic', () => {
-  describe('getNextInterval', () => {
-    test('returns 10s for 0-2 consecutive successes', () => {
-      expect(getNextInterval(0)).toBe(10_000)
-      expect(getNextInterval(1)).toBe(10_000)
-      expect(getNextInterval(2)).toBe(10_000)
-    })
-
-    test('returns 30s for 3-5 consecutive successes', () => {
-      expect(getNextInterval(3)).toBe(30_000)
-      expect(getNextInterval(4)).toBe(30_000)
-      expect(getNextInterval(5)).toBe(30_000)
-    })
-
-    test('returns 60s for 6-9 consecutive successes', () => {
-      expect(getNextInterval(6)).toBe(60_000)
-      expect(getNextInterval(7)).toBe(60_000)
-      expect(getNextInterval(8)).toBe(60_000)
-      expect(getNextInterval(9)).toBe(60_000)
-    })
-
-    test('returns 2min for 10-14 consecutive successes', () => {
-      expect(getNextInterval(10)).toBe(120_000)
-      expect(getNextInterval(11)).toBe(120_000)
-      expect(getNextInterval(14)).toBe(120_000)
-    })
-
-    test('returns 5min for 15-19 consecutive successes', () => {
-      expect(getNextInterval(15)).toBe(300_000)
-      expect(getNextInterval(16)).toBe(300_000)
-      expect(getNextInterval(19)).toBe(300_000)
-    })
-
-    test('returns 10min (max) for 20+ consecutive successes', () => {
-      expect(getNextInterval(20)).toBe(600_000)
-      expect(getNextInterval(25)).toBe(600_000)
-      expect(getNextInterval(100)).toBe(600_000)
-      expect(getNextInterval(1000)).toBe(600_000)
-    })
-  })
-
-  describe('interval progression', () => {
-    test('progresses through all thresholds in order', () => {
-      const progression = [
-        { successes: 0, expectedInterval: 10_000 },
-        { successes: 3, expectedInterval: 30_000 },
-        { successes: 6, expectedInterval: 60_000 },
-        { successes: 10, expectedInterval: 120_000 },
-        { successes: 15, expectedInterval: 300_000 },
-        { successes: 20, expectedInterval: 600_000 },
-      ]
-
-      for (const { successes, expectedInterval } of progression) {
-        expect(getNextInterval(successes)).toBe(expectedInterval)
-      }
-    })
-
-    test('intervals increase monotonically', () => {
-      let previousInterval = 0
-      // Test first occurrence of each threshold
-      const testPoints = [0, 3, 6, 10, 15, 20, 50]
-
-      for (const successes of testPoints) {
-        const interval = getNextInterval(successes)
-        expect(interval).toBeGreaterThanOrEqual(previousInterval)
-        previousInterval = interval
-      }
-    })
-  })
-
-  describe('edge cases', () => {
-    test('handles negative values (treated as 0)', () => {
-      // In practice, consecutive successes should never be negative,
-      // but the function should handle it gracefully
-      expect(getNextInterval(-1)).toBe(10_000)
-      expect(getNextInterval(-100)).toBe(10_000)
-    })
-
-    test('handles very large values', () => {
-      expect(getNextInterval(Number.MAX_SAFE_INTEGER)).toBe(600_000)
-    })
-  })
-
-  describe('boundary conditions', () => {
-    test('uses correct interval at exact threshold boundaries', () => {
-      // At threshold - 1: should use previous interval
-      expect(getNextInterval(2)).toBe(10_000) // Just before 3
-      expect(getNextInterval(5)).toBe(30_000) // Just before 6
-      expect(getNextInterval(9)).toBe(60_000) // Just before 10
-      expect(getNextInterval(14)).toBe(120_000) // Just before 15
-      expect(getNextInterval(19)).toBe(300_000) // Just before 20
-
-      // At threshold: should use new interval
-      expect(getNextInterval(3)).toBe(30_000)
-      expect(getNextInterval(6)).toBe(60_000)
-      expect(getNextInterval(10)).toBe(120_000)
-      expect(getNextInterval(15)).toBe(300_000)
-      expect(getNextInterval(20)).toBe(600_000)
-    })
-  })
-})

package/src/hooks/__tests__/use-directory-browser.test.ts

@@ -1,203 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  rmSync,
-  statSync,
-  writeFileSync,
-} from 'fs'
-import os from 'os'
-import path from 'path'
-
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
-
-/**
- * Tests for useDirectoryBrowser hook logic.
- *
- * These tests focus on the pure logic aspects of the hook:
- * - expandPath: Expands ~ to home directory
- * - Path validation and navigation logic
- */
-
-// Extract the pure expandPath logic for testing
-const expandPath = (inputPath: string): string => {
-  if (inputPath.startsWith('~')) {
-    return path.join(os.homedir(), inputPath.slice(1))
-  }
-  return inputPath
-}
-
-// Extract the path validation logic for testing
-const isValidDirectoryPath = (inputPath: string): boolean => {
-  const expandedPath = expandPath(inputPath.trim())
-  try {
-    return existsSync(expandedPath) && statSync(expandedPath).isDirectory()
-  } catch {
-    return false
-  }
-}
-
-describe('useDirectoryBrowser - expandPath', () => {
-  const homeDir = os.homedir()
-
-  describe('tilde expansion', () => {
-    test('expands ~ to home directory', () => {
-      const result = expandPath('~')
-      expect(result).toBe(homeDir)
-    })
-
-    test('expands ~/path to home directory + path', () => {
-      const result = expandPath('~/Documents')
-      expect(result).toBe(path.join(homeDir, 'Documents'))
-    })
-
-    test('expands ~/nested/path correctly', () => {
-      const result = expandPath('~/nested/path/to/file')
-      expect(result).toBe(path.join(homeDir, 'nested/path/to/file'))
-    })
-
-    test('expands ~/ (with trailing slash) correctly', () => {
-      const result = expandPath('~/')
-      expect(result).toBe(path.join(homeDir, '/'))
-    })
-
-    test('handles ~ with special characters in path', () => {
-      const result = expandPath('~/path with spaces')
-      expect(result).toBe(path.join(homeDir, 'path with spaces'))
-    })
-  })
-
-  describe('non-tilde paths', () => {
-    test('returns absolute path unchanged', () => {
-      const result = expandPath('/usr/local/bin')
-      expect(result).toBe('/usr/local/bin')
-    })
-
-    test('returns relative path unchanged', () => {
-      const result = expandPath('relative/path')
-      expect(result).toBe('relative/path')
-    })
-
-    test('returns empty string unchanged', () => {
-      const result = expandPath('')
-      expect(result).toBe('')
-    })
-
-    test('returns dot path unchanged', () => {
-      const result = expandPath('.')
-      expect(result).toBe('.')
-    })
-
-    test('returns double dot path unchanged', () => {
-      const result = expandPath('..')
-      expect(result).toBe('..')
-    })
-
-    test('does not expand ~ in middle of path', () => {
-      const result = expandPath('/some/~/path')
-      expect(result).toBe('/some/~/path')
-    })
-
-    test('does not expand ~ at end of path', () => {
-      const result = expandPath('/some/path~')
-      expect(result).toBe('/some/path~')
-    })
-  })
-
-  describe('edge cases', () => {
-    test('handles ~user syntax (does not expand, returns as-is)', () => {
-      // In this implementation, ~user is not specially handled
-      // It would expand to homedir + 'user' which may not be intended
-      // but that's the current behavior
-      const result = expandPath('~user')
-      expect(result).toBe(path.join(homeDir, 'user'))
-    })
-
-    test('handles path with only tilde character', () => {
-      const result = expandPath('~')
-      expect(result).toBe(homeDir)
-    })
-  })
-})
-
-describe('useDirectoryBrowser - path validation', () => {
-  let tempDir: string
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(path.join(os.tmpdir(), 'dir-browser-test-'))
-  })
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true })
-  })
-
-  describe('isValidDirectoryPath', () => {
-    test('returns true for existing directory', () => {
-      expect(isValidDirectoryPath(tempDir)).toBe(true)
-    })
-
-    test('returns true for existing nested directory', () => {
-      const nestedDir = path.join(tempDir, 'nested')
-      mkdirSync(nestedDir)
-      expect(isValidDirectoryPath(nestedDir)).toBe(true)
-    })
-
-    test('returns false for non-existent path', () => {
-      expect(isValidDirectoryPath('/this/path/does/not/exist')).toBe(false)
-    })
-
-    test('returns false for file (not directory)', () => {
-      const filePath = path.join(tempDir, 'test.txt')
-      writeFileSync(filePath, 'test')
-      expect(isValidDirectoryPath(filePath)).toBe(false)
-    })
-
-    test('handles whitespace in path by trimming', () => {
-      expect(isValidDirectoryPath(`  ${tempDir}  `)).toBe(true)
-    })
-
-    test('returns false for empty string', () => {
-      expect(isValidDirectoryPath('')).toBe(false)
-    })
-
-    test('handles tilde paths correctly', () => {
-      // Home directory should exist
-      expect(isValidDirectoryPath('~')).toBe(true)
-    })
-  })
-})
-
-describe('useDirectoryBrowser - directory entry conversion', () => {
-  // Test the logic for converting directory entries to list items
-  const convertToListItem = (entry: { name: string; path: string; isParent: boolean }) => ({
-    id: entry.path,
-    label: entry.name,
-    icon: entry.isParent ? '📂' : '📁',
-  })
-
-  test('converts parent directory entry correctly', () => {
-    const entry = { name: '..', path: '/home', isParent: true }
-    const result = convertToListItem(entry)
-    
-    expect(result.id).toBe('/home')
-    expect(result.label).toBe('..')
-    expect(result.icon).toBe('📂')
-  })
-
-  test('converts regular directory entry correctly', () => {
-    const entry = { name: 'Documents', path: '/home/user/Documents', isParent: false }
-    const result = convertToListItem(entry)
-    
-    expect(result.id).toBe('/home/user/Documents')
-    expect(result.label).toBe('Documents')
-    expect(result.icon).toBe('📁')
-  })
-
-  test('handles special characters in directory names', () => {
-    const entry = { name: 'My Folder (2024)', path: '/home/My Folder (2024)', isParent: false }
-    const result = convertToListItem(entry)
-    
-    expect(result.id).toBe('/home/My Folder (2024)')
-    expect(result.label).toBe('My Folder (2024)')
-  })
-})