@alumbwe/anvil 1.0.19 → 1.0.20

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

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

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

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

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

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

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