@alumbwe/anvil 1.0.42 → 1.0.49

package/src/hooks/__tests__/use-message-queue-editing.test.tsx

@@ -1,209 +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 { useMessageQueue } from '../use-message-queue'
-
-/**
- * Mounts the queue with the stream held busy, so nothing drains and the tests
- * can act on a queue that stays put — the state the queue editor works in.
- */
-async function mountBusyQueue() {
-  const isChainInProgressRef = { current: true }
-  const activeAgentStreamsRef = { current: 0 }
-  const sent: Array<{ content: string; attachments: unknown[] }> = []
-  let queue: ReturnType<typeof useMessageQueue> | undefined
-
-  const Harness = () => {
-    queue = useMessageQueue(
-      async (message) => {
-        sent.push({
-          content: message.content,
-          attachments: message.attachments,
-        })
-      },
-      isChainInProgressRef,
-      activeAgentStreamsRef,
-    )
-    return <text>{String(queue.queuedMessages.length)}</text>
-  }
-
-  const setup = await createTestRenderer({ width: 20, height: 2 })
-  const root = createRoot(setup.renderer)
-  flushSync(() => root.render(<Harness />))
-  await setup.renderOnce()
-
-  const act = async (fn: () => void) => {
-    flushSync(fn)
-    await setup.renderOnce()
-    await new Promise((resolve) => setTimeout(resolve, 10))
-    await setup.renderOnce()
-  }
-
-  return {
-    get queue() {
-      return queue!
-    },
-    contents: () => queue!.queuedMessages.map((message) => message.content),
-    /** What the agent was actually handed, in the order it was handed over. */
-    sent: () => sent,
-    act,
-    /** The in-flight run finishes, so the queue is free to drain. */
-    async finishRun() {
-      await act(() => {
-        isChainInProgressRef.current = false
-        queue!.setCanProcessQueue(false)
-      })
-      await act(() => queue!.setCanProcessQueue(true))
-      for (let pass = 0; pass < 5; pass++) await act(() => {})
-    },
-    dispose() {
-      flushSync(() => root.unmount())
-      setup.renderer.destroy()
-    },
-  }
-}
-
-describe('queue editing', () => {
-  test('edits, deletes, and reorders queued messages by id', async () => {
-    const harness = await mountBusyQueue()
-    try {
-      await harness.act(() => {
-        harness.queue.addToQueue('one')
-        harness.queue.addToQueue('two')
-        harness.queue.addToQueue('three')
-      })
-      expect(harness.contents()).toEqual(['one', 'two', 'three'])
-
-      const ids = harness.queue.queuedMessages.map((message) => message.id)
-      expect(new Set(ids).size).toBe(3)
-
-      await harness.act(() => {
-        expect(harness.queue.editQueuedMessage(ids[1]!, 'two (edited)')).toBe(
-          true,
-        )
-      })
-      expect(harness.contents()).toEqual(['one', 'two (edited)', 'three'])
-
-      // Moving keeps the id, so the caller's selection survives the reorder.
-      await harness.act(() => {
-        expect(harness.queue.moveQueuedMessage(ids[2]!, 0)).toBe(true)
-      })
-      expect(harness.contents()).toEqual(['three', 'one', 'two (edited)'])
-      expect(harness.queue.queuedMessages[0]!.id).toBe(ids[2]!)
-
-      await harness.act(() => {
-        expect(harness.queue.removeQueuedMessage(ids[0]!)).toBe(true)
-      })
-      expect(harness.contents()).toEqual(['three', 'two (edited)'])
-    } finally {
-      harness.dispose()
-    }
-  })
-
-  test('a move past either end clamps instead of dropping the message', async () => {
-    const harness = await mountBusyQueue()
-    try {
-      await harness.act(() => {
-        harness.queue.addToQueue('one')
-        harness.queue.addToQueue('two')
-      })
-      const ids = harness.queue.queuedMessages.map((message) => message.id)
-
-      await harness.act(() => {
-        expect(harness.queue.moveQueuedMessage(ids[0]!, -3)).toBe(false)
-      })
-      expect(harness.contents()).toEqual(['one', 'two'])
-
-      await harness.act(() => {
-        expect(harness.queue.moveQueuedMessage(ids[0]!, 99)).toBe(true)
-      })
-      expect(harness.contents()).toEqual(['two', 'one'])
-    } finally {
-      harness.dispose()
-    }
-  })
-
-  test('editing a message that is no longer queued reports failure', async () => {
-    const harness = await mountBusyQueue()
-    try {
-      await harness.act(() => harness.queue.addToQueue('one'))
-      const [id] = harness.queue.queuedMessages.map((message) => message.id)
-
-      await harness.act(() => {
-        harness.queue.clearQueue()
-      })
-
-      await harness.act(() => {
-        expect(harness.queue.editQueuedMessage(id!, 'too late')).toBe(false)
-        expect(harness.queue.removeQueuedMessage(id!)).toBe(false)
-        expect(harness.queue.moveQueuedMessage(id!, 0)).toBe(false)
-      })
-      expect(harness.contents()).toEqual([])
-    } finally {
-      harness.dispose()
-    }
-  })
-
-  test('the agent is handed the edited queue, not the original', async () => {
-    const harness = await mountBusyQueue()
-    try {
-      await harness.act(() => {
-        harness.queue.addToQueue('one')
-        harness.queue.addToQueue('two', [{ kind: 'image' } as never])
-        harness.queue.addToQueue('three')
-      })
-      // Nothing may drain while the run that caused the queuing is in flight.
-      expect(harness.sent()).toEqual([])
-
-      const ids = harness.queue.queuedMessages.map((message) => message.id)
-      await harness.act(() => {
-        harness.queue.editQueuedMessage(ids[1]!, 'two (edited)')
-        harness.queue.moveQueuedMessage(ids[2]!, 0)
-        harness.queue.removeQueuedMessage(ids[0]!)
-      })
-      expect(harness.sent()).toEqual([])
-
-      await harness.finishRun()
-
-      // The whole point of the feature: what the user rewrote is what runs,
-      // in the order they put it in, without the message they deleted.
-      expect(harness.sent().map((send) => send.content)).toEqual([
-        'three',
-        'two (edited)',
-      ])
-      // Editing the text leaves the message's attachments alone.
-      expect(harness.sent()[1]!.attachments).toEqual([{ kind: 'image' }])
-      expect(harness.contents()).toEqual([])
-    } finally {
-      harness.dispose()
-    }
-  })
-
-  test('a message put back at the head is addressable like any other', async () => {
-    const harness = await mountBusyQueue()
-    try {
-      await harness.act(() => harness.queue.addToQueue('one'))
-
-      // An aborted send returns its message without an id; the queue mints one
-      // so the editor can still act on the row.
-      await harness.act(() => {
-        harness.queue.addToQueueFront({ content: 'zero', attachments: [] })
-      })
-      expect(harness.contents()).toEqual(['zero', 'one'])
-
-      const [restoredId] = harness.queue.queuedMessages.map(
-        (message) => message.id,
-      )
-      expect(restoredId).toBeTruthy()
-
-      await harness.act(() => {
-        expect(harness.queue.removeQueuedMessage(restoredId!)).toBe(true)
-      })
-      expect(harness.contents()).toEqual(['one'])
-    } finally {
-      harness.dispose()
-    }
-  })
-})

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

@@ -1,71 +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 { useMessageQueue } from '../use-message-queue'
-
-import type { QueuedMessage } from '../use-message-queue'
-
-describe('useMessageQueue ownership', () => {
-  test('a stale send cannot release a newer queue processing lock', async () => {
-    const sends: Array<{
-      message: QueuedMessage
-      resolve: () => void
-    }> = []
-    const isChainInProgressRef = { current: false }
-    const activeAgentStreamsRef = { current: 0 }
-    let queue: ReturnType<typeof useMessageQueue> | undefined
-
-    const Harness = () => {
-      queue = useMessageQueue(
-        (message) =>
-          new Promise<void>((resolve) => {
-            sends.push({ message, resolve })
-          }),
-        isChainInProgressRef,
-        activeAgentStreamsRef,
-      )
-      return <text>{queue.isProcessingQueueRef.current ? 'busy' : 'idle'}</text>
-    }
-
-    const setup = await createTestRenderer({ width: 20, height: 2 })
-    const root = createRoot(setup.renderer)
-    flushSync(() => root.render(<Harness />))
-    await setup.renderOnce()
-
-    try {
-      flushSync(() => queue!.addToQueue('run A'))
-      await setup.renderOnce()
-      expect(sends.map((send) => send.message.content)).toEqual(['run A'])
-      expect(queue!.isProcessingQueueRef.current).toBe(true)
-
-      // Match the active-run abort handler: it releases the public boolean so
-      // another queued run can start before run A's promise settles.
-      flushSync(() => {
-        queue!.isProcessingQueueRef.current = false
-        queue!.setCanProcessQueue(true)
-        queue!.addToQueue('run B')
-      })
-      await setup.renderOnce()
-      expect(sends.map((send) => send.message.content)).toEqual([
-        'run A',
-        'run B',
-      ])
-      expect(queue!.isProcessingQueueRef.current).toBe(true)
-
-      sends[0]!.resolve()
-      await Promise.resolve()
-      await setup.renderOnce()
-      expect(queue!.isProcessingQueueRef.current).toBe(true)
-
-      sends[1]!.resolve()
-      await Promise.resolve()
-      await setup.renderOnce()
-      expect(queue!.isProcessingQueueRef.current).toBe(false)
-    } finally {
-      flushSync(() => root.unmount())
-      setup.renderer.destroy()
-    }
-  })
-})

package/src/hooks/__tests__/use-path-tab-completion.test.ts

@@ -1,315 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync } from 'fs'
-import os from 'os'
-import path from 'path'
-
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test'
-
-/**
- * Tests for usePathTabCompletion hook logic.
- *
- * These tests focus on the pure logic aspects of the hook:
- * - Path type detection (absolute vs relative)
- * - Completion behavior with navigation enabled/disabled
- * - Path transformation for display
- */
-
-// Helper to expand ~ to home directory (same as in the hook)
-const expandPath = (inputPath: string): string => {
-  if (inputPath.startsWith('~')) {
-    return path.join(os.homedir(), inputPath.slice(1))
-  }
-  return inputPath
-}
-
-// Helper to check if a path is absolute-style (starts with / or ~)
-const isAbsolutePath = (searchQuery: string): boolean => {
-  return searchQuery.startsWith('/') || searchQuery.startsWith('~')
-}
-
-// Helper to check if completion result indicates a full directory
-const isCompleteDirectory = (completed: string): boolean => {
-  return completed.endsWith('/')
-}
-
-// Helper to convert absolute completion back to relative for display
-const toRelativePath = (
-  completed: string,
-  currentPath: string,
-): string | null => {
-  if (completed.startsWith(currentPath + path.sep)) {
-    return completed.slice(currentPath.length + 1)
-  }
-  return null
-}
-
-describe('usePathTabCompletion - path type detection', () => {
-  describe('isAbsolutePath', () => {
-    test('returns true for paths starting with /', () => {
-      expect(isAbsolutePath('/usr/local')).toBe(true)
-      expect(isAbsolutePath('/home')).toBe(true)
-      expect(isAbsolutePath('/')).toBe(true)
-    })
-
-    test('returns true for paths starting with ~', () => {
-      expect(isAbsolutePath('~')).toBe(true)
-      expect(isAbsolutePath('~/Documents')).toBe(true)
-      expect(isAbsolutePath('~/')).toBe(true)
-    })
-
-    test('returns false for relative paths', () => {
-      expect(isAbsolutePath('Documents')).toBe(false)
-      expect(isAbsolutePath('src/components')).toBe(false)
-      expect(isAbsolutePath('./relative')).toBe(false)
-      expect(isAbsolutePath('../parent')).toBe(false)
-    })
-
-    test('returns false for empty string', () => {
-      expect(isAbsolutePath('')).toBe(false)
-    })
-
-    test('returns false for paths with ~ in middle', () => {
-      expect(isAbsolutePath('some/~/path')).toBe(false)
-      expect(isAbsolutePath('path~')).toBe(false)
-    })
-  })
-})
-
-describe('usePathTabCompletion - completion result detection', () => {
-  describe('isCompleteDirectory', () => {
-    test('returns true for paths ending with /', () => {
-      expect(isCompleteDirectory('/usr/local/')).toBe(true)
-      expect(isCompleteDirectory('~/Documents/')).toBe(true)
-      expect(isCompleteDirectory('relative/path/')).toBe(true)
-    })
-
-    test('returns false for paths not ending with /', () => {
-      expect(isCompleteDirectory('/usr/local')).toBe(false)
-      expect(isCompleteDirectory('~/Documents')).toBe(false)
-      expect(isCompleteDirectory('partial')).toBe(false)
-    })
-
-    test('returns false for empty string', () => {
-      expect(isCompleteDirectory('')).toBe(false)
-    })
-
-    test('handles path with only /', () => {
-      expect(isCompleteDirectory('/')).toBe(true)
-    })
-  })
-})
-
-describe('usePathTabCompletion - relative path conversion', () => {
-  describe('toRelativePath', () => {
-    test('converts absolute completion to relative when within currentPath', () => {
-      const currentPath = '/home/user/projects'
-      const completed = '/home/user/projects/myproject'
-      
-      const result = toRelativePath(completed, currentPath)
-      expect(result).toBe('myproject')
-    })
-
-    test('converts nested path correctly', () => {
-      const currentPath = '/home/user'
-      const completed = '/home/user/Documents/work'
-      
-      const result = toRelativePath(completed, currentPath)
-      expect(result).toBe('Documents/work')
-    })
-
-    test('returns null when completion is not under currentPath', () => {
-      const currentPath = '/home/user/projects'
-      const completed = '/usr/local/bin'
-      
-      const result = toRelativePath(completed, currentPath)
-      expect(result).toBeNull()
-    })
-
-    test('returns null when completion exactly equals currentPath', () => {
-      const currentPath = '/home/user/projects'
-      const completed = '/home/user/projects'
-      
-      // Note: This would need to be `/home/user/projects/` + something to match
-      const result = toRelativePath(completed, currentPath)
-      expect(result).toBeNull()
-    })
-
-    test('handles paths with trailing separators correctly', () => {
-      const currentPath = '/home/user'
-      const completed = '/home/user/test'
-      
-      const result = toRelativePath(completed, currentPath)
-      expect(result).toBe('test')
-    })
-  })
-})
-
-describe('usePathTabCompletion - expandPath behavior', () => {
-  const homeDir = os.homedir()
-
-  test('expands tilde in completion paths', () => {
-    const result = expandPath('~/Documents')
-    expect(result).toBe(path.join(homeDir, 'Documents'))
-  })
-
-  test('leaves absolute paths unchanged', () => {
-    const result = expandPath('/usr/local/bin')
-    expect(result).toBe('/usr/local/bin')
-  })
-
-  test('leaves relative paths unchanged', () => {
-    const result = expandPath('relative/path')
-    expect(result).toBe('relative/path')
-  })
-})
-
-describe('usePathTabCompletion - completion decision logic', () => {
-  /**
-   * Test the decision logic that determines:
-   * 1. Whether to complete at all
-   * 2. Whether to navigate (change currentPath) or just update searchQuery
-   */
-
-  describe('when query is empty', () => {
-    test('should not attempt completion for empty query', () => {
-      const searchQuery = ''
-      const shouldComplete = searchQuery.length > 0 || isAbsolutePath(searchQuery)
-      expect(shouldComplete).toBe(false)
-    })
-  })
-
-  describe('when query is absolute path', () => {
-    test('should attempt completion for / prefix', () => {
-      const searchQuery = '/usr'
-      expect(isAbsolutePath(searchQuery)).toBe(true)
-    })
-
-    test('should attempt completion for ~ prefix', () => {
-      const searchQuery = '~/Doc'
-      expect(isAbsolutePath(searchQuery)).toBe(true)
-    })
-  })
-
-  describe('when query is relative path', () => {
-    test('should attempt completion when query has content', () => {
-      const searchQuery = 'src'
-      const shouldComplete = searchQuery.length > 0
-      expect(shouldComplete).toBe(true)
-    })
-
-    test('should not attempt completion for whitespace-only query', () => {
-      const searchQuery = '   '
-      const shouldComplete = searchQuery.trim().length > 0
-      expect(shouldComplete).toBe(false)
-    })
-  })
-
-  describe('navigation decision', () => {
-    test('should navigate when canNavigate is true and completion is full directory', () => {
-      const canNavigate = true
-      const completed = '/home/user/Documents/'
-      
-      const shouldNavigate = canNavigate && isCompleteDirectory(completed)
-      expect(shouldNavigate).toBe(true)
-    })
-
-    test('should not navigate when canNavigate is false', () => {
-      const canNavigate = false
-      const completed = '/home/user/Documents/'
-      
-      const shouldNavigate = canNavigate && isCompleteDirectory(completed)
-      expect(shouldNavigate).toBe(false)
-    })
-
-    test('should not navigate when completion is partial (no trailing /)', () => {
-      const canNavigate = true
-      const completed = '/home/user/Doc'
-      
-      const shouldNavigate = canNavigate && isCompleteDirectory(completed)
-      expect(shouldNavigate).toBe(false)
-    })
-  })
-})
-
-describe('usePathTabCompletion - integration with filesystem', () => {
-  let tempDir: string
-  let nestedDir: string
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(path.join(os.tmpdir(), 'tab-completion-test-'))
-    nestedDir = path.join(tempDir, 'nested')
-    mkdirSync(nestedDir)
-    mkdirSync(path.join(nestedDir, 'subdir'))
-  })
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true })
-  })
-
-  test('builds relative path correctly for completion', () => {
-    const currentPath = tempDir
-    const searchQuery = 'nest'
-    
-    // This simulates what the hook does: join currentPath with searchQuery
-    const relativePath = path.join(currentPath, searchQuery)
-    expect(relativePath).toBe(path.join(tempDir, 'nest'))
-  })
-
-  test('extracts directory path from completion result', () => {
-    const completed = '/some/path/to/directory/'
-    
-    // Remove trailing / to get directory path for navigation
-    const dirPath = completed.slice(0, -1)
-    expect(dirPath).toBe('/some/path/to/directory')
-  })
-
-  test('converts completion result back to relative display', () => {
-    const currentPath = tempDir
-    const completed = path.join(tempDir, 'nested') + path.sep
-    
-    // Simulate the conversion logic
-    let displayPath: string
-    if (completed.startsWith(currentPath + path.sep)) {
-      displayPath = completed.slice(currentPath.length + 1)
-    } else {
-      displayPath = completed
-    }
-    
-    // Should show 'nested/' as the relative path
-    expect(displayPath).toBe('nested' + path.sep)
-  })
-})
-
-describe('usePathTabCompletion - edge cases', () => {
-  test('handles path with spaces', () => {
-    const searchQuery = '~/My Documents'
-    expect(isAbsolutePath(searchQuery)).toBe(true)
-    
-    const expanded = expandPath(searchQuery)
-    expect(expanded).toBe(path.join(os.homedir(), 'My Documents'))
-  })
-
-  test('handles path with special characters', () => {
-    const searchQuery = '~/project-v2.0'
-    const expanded = expandPath(searchQuery)
-    expect(expanded).toBe(path.join(os.homedir(), 'project-v2.0'))
-  })
-
-  test('handles double slashes in path', () => {
-    const searchQuery = '/usr//local'
-    expect(isAbsolutePath(searchQuery)).toBe(true)
-    // Note: path.join would normalize this, but the raw check doesn't
-  })
-
-  test('handles very long paths', () => {
-    const longPath = '/' + 'a'.repeat(100) + '/' + 'b'.repeat(100)
-    expect(isAbsolutePath(longPath)).toBe(true)
-  })
-
-  test('handles unicode characters in path', () => {
-    const searchQuery = '~/文档'
-    expect(isAbsolutePath(searchQuery)).toBe(true)
-    
-    const expanded = expandPath(searchQuery)
-    expect(expanded).toBe(path.join(os.homedir(), '文档'))
-  })
-})

package/src/hooks/__tests__/use-queue-controls.test.ts

@@ -1,68 +0,0 @@
-import { describe, test, expect, mock } from 'bun:test'
-
-import { createQueueCtrlCHandler } from '../use-queue-controls'
-
-import type { QueuedMessage } from '../use-message-queue'
-
-describe('createQueueCtrlCHandler', () => {
-  const setupHandler = (
-    overrides: Partial<Parameters<typeof createQueueCtrlCHandler>[0]> = {},
-  ) => {
-    const clearQueue = mock(() => [] as QueuedMessage[])
-    const resumeQueue = mock(() => {})
-    const baseHandleCtrlC = mock(() => true as const)
-
-    const handler = createQueueCtrlCHandler({
-      queuePaused: false,
-      queuedCount: 0,
-      inputHasText: false,
-      clearQueue,
-      resumeQueue,
-      baseHandleCtrlC,
-      ...overrides,
-    })
-
-    return { handler, clearQueue, resumeQueue, baseHandleCtrlC }
-  }
-
-  test('delegates to base handler when input has text even if queue is paused', () => {
-    const { handler, clearQueue, resumeQueue, baseHandleCtrlC } = setupHandler({
-      queuePaused: true,
-      queuedCount: 2,
-      inputHasText: true,
-    })
-
-    handler()
-
-    expect(clearQueue.mock.calls.length).toBe(0)
-    expect(resumeQueue.mock.calls.length).toBe(0)
-    expect(baseHandleCtrlC.mock.calls.length).toBe(1)
-  })
-
-  test('clears queued items when paused with pending work and input is empty', () => {
-    const { handler, clearQueue, resumeQueue, baseHandleCtrlC } = setupHandler({
-      queuePaused: true,
-      queuedCount: 3,
-      inputHasText: false,
-    })
-
-    handler()
-
-    expect(clearQueue.mock.calls.length).toBe(1)
-    expect(resumeQueue.mock.calls.length).toBe(1)
-    expect(baseHandleCtrlC.mock.calls.length).toBe(0)
-  })
-
-  test('delegates when there are no queued items to cancel', () => {
-    const { handler, clearQueue, resumeQueue, baseHandleCtrlC } = setupHandler({
-      queuePaused: true,
-      queuedCount: 0,
-    })
-
-    handler()
-
-    expect(clearQueue.mock.calls.length).toBe(0)
-    expect(resumeQueue.mock.calls.length).toBe(0)
-    expect(baseHandleCtrlC.mock.calls.length).toBe(1)
-  })
-})