savant-code 0.0.17 → 0.0.19

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

@@ -0,0 +1,325 @@
+import { describe, test, expect, mock } from 'bun:test'
+
+import { useFeedbackStore } from '../../state/feedback-store'
+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 =>
+    ({
+      abortControllerRef: { current: null },
+      agentMode: 'EDIT',
+      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(() => {}),
+      stopStreaming: 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('telemetry command accepts consent arguments', () => {
+      const telemetry = COMMAND_REGISTRY.find((c) => c.name === 'telemetry')
+      expect(telemetry).toBeDefined()
+      expect(telemetry?.acceptsArgs).toBe(true)
+    })
+
+    test('expected commands accept args', () => {
+      // mode:* commands also accept args now
+      const expectedWithArgs = [
+        'feedback',
+        'bash',
+        'image',
+        'publish',
+        'new',
+        'mode:edit',
+        'mode:scaffold',
+        'mode:analyze',
+      ]
+      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('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: 'EDIT',
+      })
+    })
+
+    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/cli/src/commands/__tests__/copy-conversation.test.ts

@@ -0,0 +1,240 @@
+import { describe, test, expect } from 'bun:test'
+
+import { serializeConversation } from '../copy-conversation'
+
+import type { ChatMessage, ContentBlock } from '../../types/chat'
+import type { JSONValue } from '@savant-code/common/types/json'
+
+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: Record<string, JSONValue>,
+  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: {},
+            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(/# (SavantFree|SavantCode) conversation/)
+    expect(omittedCount).toBe(0)
+  })
+})

package/cli/src/commands/__tests__/dev-command.test.ts

@@ -0,0 +1,128 @@
+import { describe, test, expect, mock, beforeEach } from 'bun:test'
+
+import { useChatStore } from '../../state/chat-store'
+import { findCommand } from '../command-registry'
+
+import type { RouterParams } from '../command-registry'
+
+describe('/dev command', () => {
+  const createMockParams = (
+    overrides: Partial<RouterParams> = {},
+  ): RouterParams =>
+    ({
+      abortControllerRef: { current: null },
+      agentMode: 'EDIT',
+      inputRef: { current: null },
+      inputValue: '/dev on',
+      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(() => {}),
+      stopStreaming: mock(() => {}),
+      ...overrides,
+    }) as RouterParams
+
+  beforeEach(() => {
+    useChatStore.getState().setDevMode(false)
+  })
+
+  test('findCommand returns /dev command', () => {
+    const dev = findCommand('dev')
+    expect(dev).toBeDefined()
+    expect(dev?.name).toBe('dev')
+    expect(dev?.acceptsArgs).toBe(true)
+  })
+
+  test('/dev on activates dev override', () => {
+    const dev = findCommand('dev')
+    const params = createMockParams({ inputValue: '/dev on' })
+
+    expect(useChatStore.getState().devMode).toBe(false)
+    dev!.handler(params, 'on')
+
+    expect(useChatStore.getState().devMode).toBe(true)
+    expect(params.setMessages).toHaveBeenCalled()
+  })
+
+  test('/dev off deactivates dev override', () => {
+    useChatStore.getState().setDevMode(true)
+    const dev = findCommand('dev')
+    const params = createMockParams({ inputValue: '/dev off' })
+
+    dev!.handler(params, 'off')
+
+    expect(useChatStore.getState().devMode).toBe(false)
+  })
+
+  test('bare /dev activates dev override', () => {
+    const dev = findCommand('dev')
+    const params = createMockParams({ inputValue: '/dev' })
+
+    dev!.handler(params, '')
+
+    expect(useChatStore.getState().devMode).toBe(true)
+  })
+
+  test('/dev on when already active reports already active', () => {
+    useChatStore.getState().setDevMode(true)
+    const dev = findCommand('dev')
+    const params = createMockParams({ inputValue: '/dev on' })
+
+    dev!.handler(params, 'on')
+
+    expect(useChatStore.getState().devMode).toBe(true)
+    const setMessagesCall = (params.setMessages as ReturnType<typeof mock>).mock
+      .calls[0][0]
+    const newMessages = setMessagesCall([])
+    const messageText = JSON.stringify(newMessages)
+    expect(messageText).toContain('already active')
+  })
+
+  test('/dev off when already off reports already off', () => {
+    useChatStore.getState().setDevMode(false)
+    const dev = findCommand('dev')
+    const params = createMockParams({ inputValue: '/dev off' })
+
+    dev!.handler(params, 'off')
+
+    expect(useChatStore.getState().devMode).toBe(false)
+    const setMessagesCall = (params.setMessages as ReturnType<typeof mock>).mock
+      .calls[0][0]
+    const newMessages = setMessagesCall([])
+    const messageText = JSON.stringify(newMessages)
+    expect(messageText).toContain('already off')
+  })
+
+  test('unknown /dev subcommand reports usage', () => {
+    const dev = findCommand('dev')
+    const params = createMockParams({ inputValue: '/dev password' })
+
+    dev!.handler(params, 'password')
+
+    expect(useChatStore.getState().devMode).toBe(false)
+    const setMessagesCall = (params.setMessages as ReturnType<typeof mock>).mock
+      .calls[0][0]
+    const newMessages = setMessagesCall([])
+    const messageText = JSON.stringify(newMessages)
+    expect(messageText).toContain('Unknown /dev subcommand')
+    expect(messageText).toContain('/dev on')
+    expect(messageText).toContain('/dev off')
+  })
+
+  test('/dev is case-insensitive', () => {
+    const dev = findCommand('DEV')
+    expect(dev).toBeDefined()
+    expect(dev?.name).toBe('dev')
+  })
+})