@alumbwe/anvil 1.0.0 → 1.0.1

package/src/commands/__tests__/command-args.test.ts

@@ -1,349 +0,0 @@
-import { describe, test, expect, mock } from 'bun:test'
-
-import { useFeedbackStore } from '../../state/feedback-store'
-import {
-  registerActiveRun,
-  stopActiveRun,
-  type ActiveRunStopReason,
-} from '../../utils/active-run'
-import {
-  COMMAND_REGISTRY,
-  defineCommand,
-  defineCommandWithArgs,
-} from '../command-registry'
-
-import type { RouterParams } from '../command-registry'
-
-/**
- * Tests for the command factory pattern.
- *
- * The factory pattern ensures commands handle arguments correctly:
- * - defineCommand: creates commands that gracefully ignore arguments
- * - defineCommandWithArgs: creates commands that receive and handle arguments
- */
-describe('command factory pattern', () => {
-  const createMockParams = (
-    overrides: Partial<RouterParams> = {},
-  ): RouterParams =>
-    ({
-      agentMode: 'DEFAULT',
-      inputRef: { current: null },
-      inputValue: '/test',
-      isChainInProgressRef: { current: false },
-      isStreaming: false,
-      logoutMutation: {} as RouterParams['logoutMutation'],
-      streamMessageIdRef: { current: null },
-      addToQueue: mock(() => {}),
-      clearMessages: mock(() => {}),
-      saveToHistory: mock(() => {}),
-      scrollToLatest: mock(() => {}),
-      sendMessage: mock(async () => {}),
-      setCanProcessQueue: mock(() => {}),
-      setInputFocused: mock(() => {}),
-      setInputValue: mock(() => {}),
-      setIsAuthenticated: mock(() => {}),
-      setMessages: mock(() => {}),
-      setUser: mock(() => {}),
-      ...overrides,
-    }) as RouterParams
-
-  describe('defineCommand (gracefully ignores args)', () => {
-    test('calls handler when no args provided', () => {
-      const handler = mock(() => {})
-      const cmd = defineCommand({
-        name: 'test',
-        handler,
-      })
-
-      const params = createMockParams()
-      cmd.handler(params, '')
-
-      expect(handler).toHaveBeenCalledWith(params)
-    })
-
-    test('calls handler even when args are provided (gracefully ignores)', () => {
-      const handler = mock(() => {})
-      const cmd = defineCommand({
-        name: 'test',
-        handler,
-      })
-
-      const params = createMockParams()
-      cmd.handler(params, 'some unexpected args')
-
-      // Handler should still be called - args are ignored
-      expect(handler).toHaveBeenCalledWith(params)
-    })
-
-    test('sets aliases correctly', () => {
-      const cmd = defineCommand({
-        name: 'test',
-        aliases: ['t', 'tst'],
-        handler: () => {},
-      })
-
-      expect(cmd.aliases).toEqual(['t', 'tst'])
-    })
-
-    test('defaults to empty aliases when not provided', () => {
-      const cmd = defineCommand({
-        name: 'test',
-        handler: () => {},
-      })
-
-      expect(cmd.aliases).toEqual([])
-    })
-
-    test('sets acceptsArgs to false', () => {
-      const cmd = defineCommand({
-        name: 'test',
-        handler: () => {},
-      })
-
-      expect(cmd.acceptsArgs).toBe(false)
-    })
-  })
-
-  describe('defineCommandWithArgs', () => {
-    test('passes args to handler', () => {
-      const handler = mock(() => {})
-      const cmd = defineCommandWithArgs({
-        name: 'test',
-        handler,
-      })
-
-      const params = createMockParams()
-      cmd.handler(params, 'some args')
-
-      expect(handler).toHaveBeenCalledWith(params, 'some args')
-    })
-
-    test('passes empty args to handler', () => {
-      const handler = mock(() => {})
-      const cmd = defineCommandWithArgs({
-        name: 'test',
-        handler,
-      })
-
-      const params = createMockParams()
-      cmd.handler(params, '')
-
-      expect(handler).toHaveBeenCalledWith(params, '')
-    })
-
-    test('sets aliases correctly', () => {
-      const cmd = defineCommandWithArgs({
-        name: 'test',
-        aliases: ['t', 'tst'],
-        handler: () => {},
-      })
-
-      expect(cmd.aliases).toEqual(['t', 'tst'])
-    })
-
-    test('sets acceptsArgs to true', () => {
-      const cmd = defineCommandWithArgs({
-        name: 'test',
-        handler: () => {},
-      })
-
-      expect(cmd.acceptsArgs).toBe(true)
-    })
-  })
-
-  describe('COMMAND_REGISTRY commands', () => {
-    const noArgsCommands = COMMAND_REGISTRY.filter((cmd) => !cmd.acceptsArgs)
-    const withArgsCommands = COMMAND_REGISTRY.filter((cmd) => cmd.acceptsArgs)
-
-    test('there are commands that ignore args', () => {
-      expect(noArgsCommands.length).toBeGreaterThan(0)
-    })
-
-    test('there are commands that accept args', () => {
-      expect(withArgsCommands.length).toBeGreaterThan(0)
-    })
-
-    test('expected commands ignore args', () => {
-      const expectedNoArgs = ['login', 'logout', 'exit', 'usage', 'init']
-      for (const name of expectedNoArgs) {
-        const cmd = COMMAND_REGISTRY.find((c) => c.name === name)
-        expect(cmd, `Command ${name} should exist`).toBeDefined()
-        expect(cmd?.acceptsArgs, `Command ${name} should not accept args`).toBe(
-          false,
-        )
-      }
-    })
-
-    test('expected commands accept args', () => {
-      // mode:* commands also accept args now
-      const expectedWithArgs = [
-        'feedback',
-        'bash',
-        'image',
-        'publish',
-        'new',
-        'mode:default',
-        'mode:max',
-        'mode:plan',
-      ]
-      for (const name of expectedWithArgs) {
-        const cmd = COMMAND_REGISTRY.find((c) => c.name === name)
-        expect(cmd, `Command ${name} should exist`).toBeDefined()
-        expect(cmd?.acceptsArgs, `Command ${name} should accept args`).toBe(
-          true,
-        )
-      }
-    })
-
-    test('mode commands accept args to send as first message', () => {
-      const modeCommands = COMMAND_REGISTRY.filter((cmd) =>
-        cmd.name.startsWith('mode:'),
-      )
-      expect(modeCommands.length).toBeGreaterThan(0)
-      for (const cmd of modeCommands) {
-        expect(
-          cmd.acceptsArgs,
-          `Mode command ${cmd.name} should accept args`,
-        ).toBe(true)
-      }
-    })
-  })
-
-  describe('cancellation reasons', () => {
-    test('/logout stops the owned run before starting logout', () => {
-      const reasons: ActiveRunStopReason[] = []
-      registerActiveRun('logout-run', (reason) => reasons.push(reason))
-      const mutate = mock(() => {})
-      const logoutCmd = COMMAND_REGISTRY.find((command) =>
-        command.aliases.includes('signout'),
-      )
-
-      try {
-        logoutCmd?.handler(
-          createMockParams({
-            logoutMutation: {
-              mutate,
-            } as unknown as RouterParams['logoutMutation'],
-          }),
-          '',
-        )
-
-        expect(reasons).toEqual(['logout'])
-        expect(mutate).toHaveBeenCalledTimes(1)
-      } finally {
-        stopActiveRun('process-exit')
-      }
-    })
-  })
-
-  describe('new command arg handling', () => {
-    test('clears messages and sends arg as first message when args provided', () => {
-      const newCmd = COMMAND_REGISTRY.find((c) => c.name === 'new')
-      expect(newCmd).toBeDefined()
-
-      const sendMessage = mock(async () => {})
-      const setMessages = mock(() => {})
-      const clearMessages = mock(() => {})
-      const setCanProcessQueue = mock(() => {})
-
-      const params = createMockParams({
-        inputValue: '/new hello world',
-        sendMessage,
-        setMessages,
-        clearMessages,
-        setCanProcessQueue,
-      })
-
-      newCmd!.handler(params, 'hello world')
-
-      // Should clear messages
-      expect(setMessages).toHaveBeenCalled()
-      expect(clearMessages).toHaveBeenCalled()
-
-      // Should re-enable queue and send message
-      expect(setCanProcessQueue).toHaveBeenCalledWith(true)
-      expect(sendMessage).toHaveBeenCalledWith({
-        content: 'hello world',
-        agentMode: 'DEFAULT',
-      })
-    })
-
-    test('clears messages without sending when no args provided', () => {
-      const newCmd = COMMAND_REGISTRY.find((c) => c.name === 'new')
-      expect(newCmd).toBeDefined()
-
-      const sendMessage = mock(async () => {})
-      const setMessages = mock(() => {})
-      const clearMessages = mock(() => {})
-      const setCanProcessQueue = mock(() => {})
-
-      const params = createMockParams({
-        inputValue: '/new',
-        sendMessage,
-        setMessages,
-        clearMessages,
-        setCanProcessQueue,
-      })
-
-      newCmd!.handler(params, '')
-
-      // Should clear messages
-      expect(setMessages).toHaveBeenCalled()
-      expect(clearMessages).toHaveBeenCalled()
-
-      // Should disable queue and NOT send message
-      expect(setCanProcessQueue).toHaveBeenCalledWith(false)
-      expect(sendMessage).not.toHaveBeenCalled()
-    })
-  })
-
-  describe('feedback command arg handling', () => {
-    test('pre-populates feedback text when args are provided', () => {
-      const feedbackCmd = COMMAND_REGISTRY.find((c) => c.name === 'feedback')
-      expect(feedbackCmd).toBeDefined()
-
-      // Reset the feedback store
-      useFeedbackStore.getState().reset()
-
-      const params = createMockParams({ inputValue: '/feedback my bug report' })
-      feedbackCmd!.handler(params, 'my bug report')
-
-      // Check that feedback text was pre-populated
-      const state = useFeedbackStore.getState()
-      expect(state.feedbackText).toBe('my bug report')
-      expect(state.feedbackCursor).toBe('my bug report'.length)
-    })
-
-    test('opens feedback mode without pre-populating when no args', () => {
-      const feedbackCmd = COMMAND_REGISTRY.find((c) => c.name === 'feedback')
-      expect(feedbackCmd).toBeDefined()
-
-      // Reset the feedback store
-      useFeedbackStore.getState().reset()
-
-      const params = createMockParams({ inputValue: '/feedback' })
-      const result = feedbackCmd!.handler(params, '')
-
-      // Should return openFeedbackMode
-      expect(result).toEqual({ openFeedbackMode: true })
-
-      // Feedback text should remain empty
-      const state = useFeedbackStore.getState()
-      expect(state.feedbackText).toBe('')
-    })
-
-    test('returns openFeedbackMode even with args', () => {
-      const feedbackCmd = COMMAND_REGISTRY.find((c) => c.name === 'feedback')
-      expect(feedbackCmd).toBeDefined()
-
-      // Reset the feedback store
-      useFeedbackStore.getState().reset()
-
-      const params = createMockParams({ inputValue: '/feedback test' })
-      const result = feedbackCmd!.handler(params, 'test')
-
-      // Should still return openFeedbackMode
-      expect(result).toEqual({ openFeedbackMode: true })
-    })
-  })
-})

package/src/commands/__tests__/copy-conversation-clipboard.test.ts

@@ -1,108 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
-
-import { handleCopyConversationCommand } from '../copy-conversation'
-import { useChatStore } from '../../state/chat-store'
-import {
-  clearClipboardMessage,
-  registerClipboardRenderer,
-  subscribeClipboardMessages,
-  unregisterClipboardRenderer,
-} from '../../utils/clipboard'
-
-import type { RouterParams } from '../command-registry'
-import type { ChatMessage } from '../../types/chat'
-
-const hugeMessage: ChatMessage = {
-  id: 'huge-user-message',
-  variant: 'user',
-  content: 'word '.repeat(10_000),
-  timestamp: '2026-08-13T00:00:00.000Z',
-}
-
-const commandParams = {
-  inputValue: '/copy',
-  saveToHistory: () => {},
-  setInputValue: () => {},
-} as unknown as RouterParams
-
-describe('/copy OSC 52 fallback', () => {
-  let originalPlatform: PropertyDescriptor | undefined
-  let originalEnv: Record<string, string | undefined>
-
-  beforeEach(() => {
-    originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform')
-    originalEnv = {
-      TERM: process.env.TERM,
-      SSH_CLIENT: process.env.SSH_CLIENT,
-      SSH_TTY: process.env.SSH_TTY,
-      SSH_CONNECTION: process.env.SSH_CONNECTION,
-    }
-    Object.defineProperty(process, 'platform', {
-      value: 'freebsd',
-      configurable: true,
-    })
-    process.env.TERM = 'dumb'
-    delete process.env.SSH_CLIENT
-    delete process.env.SSH_TTY
-    delete process.env.SSH_CONNECTION
-    useChatStore.setState({ messages: [hugeMessage] })
-  })
-
-  afterEach(() => {
-    unregisterClipboardRenderer()
-    clearClipboardMessage()
-    useChatStore.getState().reset()
-    if (originalPlatform) {
-      Object.defineProperty(process, 'platform', originalPlatform)
-    }
-    for (const [key, value] of Object.entries(originalEnv)) {
-      if (value === undefined) delete process.env[key]
-      else process.env[key] = value
-    }
-  })
-
-  test('uses a bounded fallback when local native copy is unavailable', async () => {
-    const clipboardWrites: string[] = []
-    registerClipboardRenderer({
-      copyToClipboardOSC52: (text: string) => {
-        clipboardWrites.push(text)
-        return true
-      },
-    })
-    const statusMessages: (string | null)[] = []
-    const unsubscribe = subscribeClipboardMessages((message) =>
-      statusMessages.push(message),
-    )
-
-    await handleCopyConversationCommand(commandParams)
-
-    expect(clipboardWrites).toHaveLength(1)
-    expect(Buffer.byteLength(clipboardWrites[0]!, 'utf8')).toBeLessThanOrEqual(
-      22_000,
-    )
-    expect(clipboardWrites[0]).toContain('truncated to fit clipboard')
-    expect(statusMessages).toContain(
-      'Copied conversation · 1 message (older messages truncated to fit clipboard)',
-    )
-    unsubscribe()
-  })
-
-  test('uses the bounded representation directly over remote OSC 52', async () => {
-    process.env.SSH_CONNECTION = '192.0.2.1 12345 192.0.2.2 22'
-    const clipboardWrites: string[] = []
-    registerClipboardRenderer({
-      copyToClipboardOSC52: (text: string) => {
-        clipboardWrites.push(text)
-        return true
-      },
-    })
-
-    await handleCopyConversationCommand(commandParams)
-
-    expect(clipboardWrites).toHaveLength(1)
-    expect(Buffer.byteLength(clipboardWrites[0]!, 'utf8')).toBeLessThanOrEqual(
-      22_000,
-    )
-    expect(clipboardWrites[0]).toContain('truncated to fit clipboard')
-  })
-})

package/src/commands/__tests__/copy-conversation.test.ts

@@ -1,226 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-
-import { serializeConversation } from '../copy-conversation'
-
-import type { ChatMessage, ContentBlock } from '../../types/chat'
-
-const msg = (
-  variant: ChatMessage['variant'],
-  opts: { content?: string; blocks?: ContentBlock[] } = {},
-): ChatMessage => ({
-  id: `${variant}-${opts.content ?? 'x'}`,
-  variant,
-  content: opts.content ?? '',
-  blocks: opts.blocks,
-  timestamp: '2026-06-25T00:00:00.000Z',
-})
-
-const toolBlock = (
-  toolName: string,
-  input: unknown,
-  output: string,
-): ContentBlock => ({
-  type: 'tool',
-  toolCallId: `call-${toolName}`,
-  toolName: toolName as ContentBlock extends { toolName: infer T } ? T : never,
-  input,
-  output,
-})
-
-describe('serializeConversation', () => {
-  test('includes user text, assistant text, and tool input + output', () => {
-    const messages: ChatMessage[] = [
-      msg('user', { content: 'Read the config file' }),
-      msg('ai', {
-        blocks: [
-          { type: 'text', content: 'Sure, reading it now.' },
-          toolBlock('read_files', { paths: ['config.ts'] }, 'export const x = 1'),
-        ],
-      }),
-    ]
-
-    const { text, omittedCount } = serializeConversation(messages)
-
-    expect(omittedCount).toBe(0)
-    expect(text).toContain('## User')
-    expect(text).toContain('Read the config file')
-    expect(text).toContain('## Assistant')
-    expect(text).toContain('Sure, reading it now.')
-    // Tool call: display name, input, and output all present.
-    expect(text).toContain('Read Files')
-    expect(text).toContain('"config.ts"')
-    expect(text).toContain('export const x = 1')
-  })
-
-  test('pretty-prints JSON tool output envelopes', () => {
-    const envelope =
-      '[{"type":"json","value":{"stdout":"hi\\n","exitCode":0}}]'
-    const messages: ChatMessage[] = [
-      msg('ai', { blocks: [toolBlock('run_terminal_command', { command: 'echo hi' }, envelope)] }),
-    ]
-    const { text } = serializeConversation(messages)
-    // Pretty-printed across multiple lines, not a single dense JSON string.
-    expect(text).toContain('"stdout": "hi\\n"')
-    expect(text).toContain('"exitCode": 0')
-    expect(text).not.toContain(envelope)
-  })
-
-  test('leaves non-JSON tool output as raw text', () => {
-    const messages: ChatMessage[] = [
-      msg('ai', { blocks: [toolBlock('read_files', { p: 'a' }, 'plain text output')] }),
-    ]
-    const { text } = serializeConversation(messages)
-    expect(text).toContain('plain text output')
-  })
-
-  test('reasoning blocks render as blockquotes', () => {
-    const messages: ChatMessage[] = [
-      msg('ai', {
-        blocks: [
-          { type: 'text', textType: 'reasoning', content: 'Thinking hard' },
-          { type: 'text', content: 'Answer' },
-        ],
-      }),
-    ]
-    const { text } = serializeConversation(messages)
-    expect(text).toContain('> _Reasoning_')
-    expect(text).toContain('> Thinking hard')
-    expect(text).toContain('Answer')
-  })
-
-  test('does not shrink when under budget', () => {
-    const messages: ChatMessage[] = [
-      msg('ai', {
-        blocks: [toolBlock('read_files', { p: 'a' }, 'short output')],
-      }),
-    ]
-    const { omittedCount } = serializeConversation(messages, { maxBytes: 10_000 })
-    expect(omittedCount).toBe(0)
-  })
-
-  test('drops largest tool results first to fit the byte budget', () => {
-    const big = 'B'.repeat(5_000)
-    const medium = 'M'.repeat(2_000)
-    const small = 'S'.repeat(200)
-    const messages: ChatMessage[] = [
-      msg('ai', {
-        blocks: [
-          toolBlock('read_files', { f: 'big' }, big),
-          toolBlock('read_files', { f: 'medium' }, medium),
-          toolBlock('read_files', { f: 'small' }, small),
-        ],
-      }),
-    ]
-
-    const maxBytes = 3_000
-    const { text, omittedCount } = serializeConversation(messages, { maxBytes })
-
-    // Result fits the budget.
-    expect(Buffer.byteLength(text, 'utf8')).toBeLessThanOrEqual(maxBytes)
-    expect(omittedCount).toBeGreaterThan(0)
-    // Largest result is omitted with a note; smallest survives intact.
-    expect(text).not.toContain(big)
-    expect(text).toContain('Result omitted')
-    expect(text).toContain(small)
-  })
-
-  test('drops tool inputs only after all outputs are dropped', () => {
-    const bigInput = { blob: 'I'.repeat(6_000) }
-    const messages: ChatMessage[] = [
-      msg('ai', {
-        blocks: [toolBlock('write_file', bigInput, 'ok')],
-      }),
-    ]
-    // Budget small enough that dropping the (tiny) output isn't sufficient,
-    // forcing the large input to be dropped too.
-    const { text } = serializeConversation(messages, { maxBytes: 1_000 })
-    expect(text).toContain('Input omitted')
-    expect(text).not.toContain('I'.repeat(6_000))
-  })
-
-  test('serializes sub-agents recursively, including nested tool calls', () => {
-    const messages: ChatMessage[] = [
-      msg('ai', {
-        blocks: [
-          {
-            type: 'agent',
-            agentId: 'a1',
-            agentName: 'Researcher',
-            agentType: 'deep-thinker',
-            content: 'I investigated the issue.',
-            status: 'complete',
-            initialPrompt: 'Find the root cause',
-            blocks: [
-              { type: 'text', content: 'Looking into it.' },
-              toolBlock('code_search', { query: 'bug' }, 'match in foo.ts'),
-            ],
-          },
-        ],
-      }),
-    ]
-
-    const { text } = serializeConversation(messages)
-    expect(text).toContain('Subagent: Researcher')
-    expect(text).toContain('Find the root cause')
-    expect(text).toContain('I investigated the issue.')
-    // Nested block + nested tool call surface in the output.
-    expect(text).toContain('Looking into it.')
-    expect(text).toContain('Code Search')
-    expect(text).toContain('match in foo.ts')
-  })
-
-  test('hard-truncates an oversized non-droppable text block as a last resort', () => {
-    // A single huge user text block — no tool bodies to drop.
-    const huge = 'word '.repeat(10_000)
-    const messages: ChatMessage[] = [msg('user', { content: huge })]
-
-    const maxBytes = 2_000
-    const { text, truncated, omittedCount } = serializeConversation(messages, {
-      maxBytes,
-    })
-
-    expect(truncated).toBe(true)
-    expect(omittedCount).toBe(0)
-    expect(Buffer.byteLength(text, 'utf8')).toBeLessThanOrEqual(maxBytes)
-    expect(text).toContain('truncated to fit clipboard')
-    // The most recent tail of the content is what survives.
-    expect(text.endsWith('word \n') || text.trimEnd().endsWith('word')).toBe(true)
-  })
-
-  test('tool call with no input or output renders a compact one-liner', () => {
-    const messages: ChatMessage[] = [
-      msg('ai', {
-        blocks: [
-          {
-            type: 'tool',
-            toolCallId: 'c1',
-            toolName: 'end_turn' as never,
-            input: null,
-            output: undefined,
-          },
-        ],
-      }),
-    ]
-    const { text } = serializeConversation(messages)
-    expect(text).toContain('(no input or output)')
-  })
-
-  test('notes attachments on user messages', () => {
-    const messages: ChatMessage[] = [
-      {
-        ...msg('user', { content: 'Look at these' }),
-        fileAttachments: [
-          { path: '/a/b.ts', filename: 'b.ts', isDirectory: false },
-        ],
-      },
-    ]
-    const { text } = serializeConversation(messages)
-    expect(text).toContain('Attached files: b.ts')
-  })
-
-  test('empty conversation still produces a header', () => {
-    const { text, omittedCount } = serializeConversation([])
-    expect(text).toMatch(/# (Freebuff|Anvil|Anvil) conversation/)
-    expect(omittedCount).toBe(0)
-  })
-})