@alumbwe/anvil 1.0.0

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

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

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

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