@alumbwe/anvil 1.0.0

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

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

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

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

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