@bytespell/shella 0.2.4 → 0.2.5

package/bundled-plugins/agent/src/reducer.test.ts

@@ -0,0 +1,359 @@
+import { describe, it, expect } from 'vitest'
+import { appReducer, handleRpcEvent, initialState, type AppState, type RpcEvent } from './reducer'
+
+describe('appReducer', () => {
+  describe('basic actions', () => {
+    it('SET_STATUS updates status', () => {
+      const state = appReducer(initialState, { type: 'SET_STATUS', status: 'connected' })
+      expect(state.status).toBe('connected')
+    })
+
+    it('SET_ERROR updates error', () => {
+      const state = appReducer(initialState, { type: 'SET_ERROR', error: 'Something went wrong' })
+      expect(state.error).toBe('Something went wrong')
+    })
+
+    it('SET_CWD updates currentCwd', () => {
+      const state = appReducer(initialState, { type: 'SET_CWD', cwd: '/home/user' })
+      expect(state.currentCwd).toBe('/home/user')
+    })
+
+    it('CWD_CHANGED clears messages and resets state', () => {
+      const stateWithMessages: AppState = {
+        ...initialState,
+        messages: [{ role: 'user', content: [{ type: 'text', text: 'Hello' }] }],
+        sessionStats: { tokens: { input: 100, output: 50, total: 150 } },
+        activeToolCalls: new Map([['call_1', { toolCallId: 'call_1', toolName: 'Bash', args: {}, status: 'running', partialOutput: null }]]),
+      }
+      const state = appReducer(stateWithMessages, { type: 'CWD_CHANGED', cwd: '/new/path' })
+      expect(state.currentCwd).toBe('/new/path')
+      expect(state.messages).toEqual([])
+      expect(state.sessionStats).toBeNull()
+      expect(state.activeToolCalls.size).toBe(0)
+    })
+
+    it('CLEAR_SESSION clears messages and stats', () => {
+      const stateWithData: AppState = {
+        ...initialState,
+        messages: [{ role: 'user', content: [{ type: 'text', text: 'Hello' }] }],
+        sessionStats: { cost: 0.01 },
+      }
+      const state = appReducer(stateWithData, { type: 'CLEAR_SESSION' })
+      expect(state.messages).toEqual([])
+      expect(state.sessionStats).toBeNull()
+    })
+  })
+})
+
+describe('handleRpcEvent', () => {
+  describe('response events', () => {
+    it('get_state response updates sessionState', () => {
+      const event: RpcEvent = {
+        type: 'response',
+        command: 'get_state',
+        success: true,
+        data: { isStreaming: false, model: { provider: 'anthropic', id: 'claude-3' } },
+      }
+      const state = handleRpcEvent(initialState, event)
+      expect(state.sessionState).toEqual({ isStreaming: false, model: { provider: 'anthropic', id: 'claude-3' } })
+    })
+
+    it('get_messages response sets messages', () => {
+      const event: RpcEvent = {
+        type: 'response',
+        command: 'get_messages',
+        success: true,
+        data: { messages: [{ role: 'user', content: [{ type: 'text', text: 'Hello' }] }] },
+      }
+      const state = handleRpcEvent(initialState, event)
+      expect(state.messages).toHaveLength(1)
+      expect(state.messages[0]?.role).toBe('user')
+    })
+
+    it('failed response does not change state', () => {
+      const event: RpcEvent = {
+        type: 'response',
+        command: 'get_state',
+        success: false,
+      }
+      const state = handleRpcEvent(initialState, event)
+      expect(state).toBe(initialState)
+    })
+
+    it('new_session response clears messages', () => {
+      const stateWithMessages: AppState = {
+        ...initialState,
+        messages: [{ role: 'user', content: [{ type: 'text', text: 'Hello' }] }],
+      }
+      const event: RpcEvent = {
+        type: 'response',
+        command: 'new_session',
+        success: true,
+      }
+      const state = handleRpcEvent(stateWithMessages, event)
+      expect(state.messages).toEqual([])
+    })
+  })
+
+  describe('agent lifecycle events', () => {
+    it('agent_start sets isStreaming and clears activeToolCalls', () => {
+      const stateWithTools: AppState = {
+        ...initialState,
+        isStreaming: false,
+        activeToolCalls: new Map([['call_1', { toolCallId: 'call_1', toolName: 'Bash', args: {}, status: 'done', partialOutput: null }]]),
+      }
+      const event: RpcEvent = { type: 'agent_start' }
+      const state = handleRpcEvent(stateWithTools, event)
+      expect(state.isStreaming).toBe(true)
+      expect(state.activeToolCalls.size).toBe(0)
+    })
+
+    it('agent_end clears streaming state', () => {
+      const streamingState: AppState = {
+        ...initialState,
+        isStreaming: true,
+        streamingMessageIndex: 1,
+        activeToolCalls: new Map([['call_1', { toolCallId: 'call_1', toolName: 'Bash', args: {}, status: 'running', partialOutput: null }]]),
+      }
+      const event: RpcEvent = { type: 'agent_end' }
+      const state = handleRpcEvent(streamingState, event)
+      expect(state.isStreaming).toBe(false)
+      expect(state.streamingMessageIndex).toBeNull()
+      expect(state.activeToolCalls.size).toBe(0)
+    })
+  })
+
+  describe('message events', () => {
+    it('message_start appends message to array', () => {
+      const event: RpcEvent = {
+        type: 'message_start',
+        message: { role: 'user', content: [{ type: 'text', text: 'Hello' }] },
+      }
+      const state = handleRpcEvent(initialState, event)
+      expect(state.messages).toHaveLength(1)
+      expect(state.messages[0]?.role).toBe('user')
+    })
+
+    it('message_start for assistant sets streamingMessageIndex', () => {
+      const stateWithUserMsg: AppState = {
+        ...initialState,
+        messages: [{ role: 'user', content: [{ type: 'text', text: 'Hello' }] }],
+      }
+      const event: RpcEvent = {
+        type: 'message_start',
+        message: { role: 'assistant', content: [{ type: 'text', text: 'Hi' }] },
+      }
+      const state = handleRpcEvent(stateWithUserMsg, event)
+      expect(state.streamingMessageIndex).toBe(1)
+    })
+
+    it('message_start for toolResult removes from activeToolCalls', () => {
+      const stateWithToolCall: AppState = {
+        ...initialState,
+        activeToolCalls: new Map([['call_1', { toolCallId: 'call_1', toolName: 'Bash', args: {}, status: 'running', partialOutput: null }]]),
+      }
+      const event: RpcEvent = {
+        type: 'message_start',
+        message: { role: 'toolResult', toolCallId: 'call_1', toolName: 'Bash', content: [{ type: 'text', text: 'output' }] },
+      }
+      const state = handleRpcEvent(stateWithToolCall, event)
+      expect(state.activeToolCalls.has('call_1')).toBe(false)
+      expect(state.messages).toHaveLength(1)
+    })
+
+    it('message_update replaces last message', () => {
+      const stateWithMsg: AppState = {
+        ...initialState,
+        messages: [{ role: 'assistant', content: [{ type: 'text', text: 'Hel' }] }],
+        streamingMessageIndex: 0,
+      }
+      const event: RpcEvent = {
+        type: 'message_update',
+        message: { role: 'assistant', content: [{ type: 'text', text: 'Hello' }] },
+      }
+      const state = handleRpcEvent(stateWithMsg, event)
+      expect(state.messages).toHaveLength(1)
+      expect((state.messages[0]?.content[0] as { type: 'text'; text: string }).text).toBe('Hello')
+    })
+
+    it('message_update on empty messages adds the message', () => {
+      const event: RpcEvent = {
+        type: 'message_update',
+        message: { role: 'assistant', content: [{ type: 'text', text: 'Hello' }] },
+      }
+      const state = handleRpcEvent(initialState, event)
+      expect(state.messages).toHaveLength(1)
+    })
+
+    it('message_end clears streamingMessageIndex', () => {
+      const streamingState: AppState = {
+        ...initialState,
+        streamingMessageIndex: 1,
+      }
+      const event: RpcEvent = { type: 'message_end' }
+      const state = handleRpcEvent(streamingState, event)
+      expect(state.streamingMessageIndex).toBeNull()
+    })
+  })
+
+  describe('tool execution events', () => {
+    it('tool_execution_start adds to activeToolCalls', () => {
+      const event: RpcEvent = {
+        type: 'tool_execution_start',
+        toolCallId: 'call_1',
+        toolName: 'Bash',
+        args: { command: 'ls' },
+      }
+      const state = handleRpcEvent(initialState, event)
+      expect(state.activeToolCalls.has('call_1')).toBe(true)
+      const toolCall = state.activeToolCalls.get('call_1')
+      expect(toolCall?.status).toBe('running')
+      expect(toolCall?.toolName).toBe('Bash')
+      expect(toolCall?.args).toEqual({ command: 'ls' })
+    })
+
+    it('tool_execution_update updates partialOutput', () => {
+      const stateWithTool: AppState = {
+        ...initialState,
+        activeToolCalls: new Map([['call_1', { toolCallId: 'call_1', toolName: 'Bash', args: {}, status: 'running', partialOutput: null }]]),
+      }
+      const event: RpcEvent = {
+        type: 'tool_execution_update',
+        toolCallId: 'call_1',
+        partialResult: { content: [{ type: 'text', text: 'partial output' }] },
+      }
+      const state = handleRpcEvent(stateWithTool, event)
+      expect(state.activeToolCalls.get('call_1')?.partialOutput).toBe('partial output')
+    })
+
+    it('tool_execution_update ignores unknown toolCallId', () => {
+      const event: RpcEvent = {
+        type: 'tool_execution_update',
+        toolCallId: 'unknown',
+        partialResult: { content: [{ type: 'text', text: 'output' }] },
+      }
+      const state = handleRpcEvent(initialState, event)
+      expect(state).toBe(initialState)
+    })
+
+    it('tool_execution_end marks as done', () => {
+      const stateWithTool: AppState = {
+        ...initialState,
+        activeToolCalls: new Map([['call_1', { toolCallId: 'call_1', toolName: 'Bash', args: {}, status: 'running', partialOutput: null }]]),
+      }
+      const event: RpcEvent = {
+        type: 'tool_execution_end',
+        toolCallId: 'call_1',
+        result: { content: [{ type: 'text', text: 'final output' }] },
+        isError: false,
+      }
+      const state = handleRpcEvent(stateWithTool, event)
+      const toolCall = state.activeToolCalls.get('call_1')
+      expect(toolCall?.status).toBe('done')
+      expect(toolCall?.partialOutput).toBe('final output')
+    })
+
+    it('tool_execution_end marks as error when isError=true', () => {
+      const stateWithTool: AppState = {
+        ...initialState,
+        activeToolCalls: new Map([['call_1', { toolCallId: 'call_1', toolName: 'Bash', args: {}, status: 'running', partialOutput: null }]]),
+      }
+      const event: RpcEvent = {
+        type: 'tool_execution_end',
+        toolCallId: 'call_1',
+        result: { content: [{ type: 'text', text: 'error message' }] },
+        isError: true,
+      }
+      const state = handleRpcEvent(stateWithTool, event)
+      expect(state.activeToolCalls.get('call_1')?.status).toBe('error')
+    })
+  })
+
+  describe('full conversation flow', () => {
+    it('handles complete tool call cycle', () => {
+      let state = initialState
+
+      // User sends message
+      state = handleRpcEvent(state, {
+        type: 'message_start',
+        message: { role: 'user', content: [{ type: 'text', text: 'list files' }] },
+      })
+      expect(state.messages).toHaveLength(1)
+
+      // Agent starts
+      state = handleRpcEvent(state, { type: 'agent_start' })
+      expect(state.isStreaming).toBe(true)
+
+      // Assistant message with tool call starts
+      state = handleRpcEvent(state, {
+        type: 'message_start',
+        message: {
+          role: 'assistant',
+          content: [
+            { type: 'text', text: 'Let me list the files.' },
+            { type: 'toolCall', id: 'call_1', name: 'Bash', arguments: { command: 'ls' } },
+          ],
+        },
+      })
+      expect(state.messages).toHaveLength(2)
+      expect(state.streamingMessageIndex).toBe(1)
+
+      // Message streaming ends
+      state = handleRpcEvent(state, { type: 'message_end' })
+      expect(state.streamingMessageIndex).toBeNull()
+
+      // Tool execution starts
+      state = handleRpcEvent(state, {
+        type: 'tool_execution_start',
+        toolCallId: 'call_1',
+        toolName: 'Bash',
+        args: { command: 'ls' },
+      })
+      expect(state.activeToolCalls.has('call_1')).toBe(true)
+
+      // Tool execution updates with partial output
+      state = handleRpcEvent(state, {
+        type: 'tool_execution_update',
+        toolCallId: 'call_1',
+        partialResult: { content: [{ type: 'text', text: 'file1.txt' }] },
+      })
+      expect(state.activeToolCalls.get('call_1')?.partialOutput).toBe('file1.txt')
+
+      // Tool execution ends
+      state = handleRpcEvent(state, {
+        type: 'tool_execution_end',
+        toolCallId: 'call_1',
+        result: { content: [{ type: 'text', text: 'file1.txt\nfile2.txt' }] },
+      })
+      expect(state.activeToolCalls.get('call_1')?.status).toBe('done')
+
+      // Tool result message arrives - should remove from activeToolCalls
+      state = handleRpcEvent(state, {
+        type: 'message_start',
+        message: {
+          role: 'toolResult',
+          toolCallId: 'call_1',
+          toolName: 'Bash',
+          content: [{ type: 'text', text: 'file1.txt\nfile2.txt' }],
+        },
+      })
+      expect(state.activeToolCalls.has('call_1')).toBe(false)
+      expect(state.messages).toHaveLength(3)
+
+      // Assistant continues with analysis
+      state = handleRpcEvent(state, {
+        type: 'message_start',
+        message: {
+          role: 'assistant',
+          content: [{ type: 'text', text: 'There are 2 files.' }],
+        },
+      })
+      expect(state.messages).toHaveLength(4)
+
+      // Agent ends
+      state = handleRpcEvent(state, { type: 'agent_end' })
+      expect(state.isStreaming).toBe(false)
+      expect(state.activeToolCalls.size).toBe(0)
+    })
+  })
+})

package/bundled-plugins/agent/src/reducer.ts

@@ -0,0 +1,255 @@
+import type { AgentMessage, ActiveToolCall, SessionState, SessionStats, AvailableModel, ToolResultMessage, ContentBlock } from './types'
+
+// =============================================================================
+// State shape
+// =============================================================================
+
+export interface AppState {
+  // Connection
+  status: 'connecting' | 'connected' | 'disconnected' | 'error'
+  error: string | null
+  currentCwd: string | null
+
+  // Auth
+  authStatus: { authenticated: boolean; providers: string[] } | null
+
+  // Session
+  sessionState: SessionState | null
+  sessionStats: SessionStats | null
+  availableModels: AvailableModel[]
+
+  // Messages - THE source of truth for rendering
+  messages: AgentMessage[]
+
+  // Streaming indicators
+  isStreaming: boolean
+  streamingMessageIndex: number | null
+
+  // Active tool calls (for progress indicators during execution)
+  activeToolCalls: Map<string, ActiveToolCall>
+}
+
+export const initialState: AppState = {
+  status: 'connecting',
+  error: null,
+  currentCwd: null,
+  authStatus: null,
+  sessionState: null,
+  sessionStats: null,
+  availableModels: [],
+  messages: [],
+  isStreaming: false,
+  streamingMessageIndex: null,
+  activeToolCalls: new Map(),
+}
+
+// =============================================================================
+// Actions
+// =============================================================================
+
+export type Action =
+  | { type: 'SET_STATUS'; status: AppState['status'] }
+  | { type: 'SET_ERROR'; error: string | null }
+  | { type: 'SET_CWD'; cwd: string }
+  | { type: 'CWD_CHANGED'; cwd: string }
+  | { type: 'SET_AUTH_STATUS'; authStatus: AppState['authStatus'] }
+  | { type: 'SET_SESSION_STATE'; sessionState: SessionState }
+  | { type: 'SET_SESSION_STATS'; sessionStats: SessionStats }
+  | { type: 'SET_AVAILABLE_MODELS'; models: AvailableModel[] }
+  | { type: 'SET_MESSAGES'; messages: AgentMessage[] }
+  | { type: 'CLEAR_SESSION' }
+  | { type: 'RPC_EVENT'; event: RpcEvent }
+
+export type RpcEvent =
+  | { type: 'response'; command: string; success: boolean; data?: unknown }
+  | { type: 'agent_start' }
+  | { type: 'agent_end' }
+  | { type: 'message_start'; message: AgentMessage }
+  | { type: 'message_update'; message: AgentMessage }
+  | { type: 'message_end' }
+  | { type: 'tool_execution_start'; toolCallId: string; toolName: string; args: Record<string, unknown> }
+  | { type: 'tool_execution_update'; toolCallId: string; partialResult?: { content?: ContentBlock[] } }
+  | { type: 'tool_execution_end'; toolCallId: string; result?: { content?: ContentBlock[] }; isError?: boolean }
+
+// =============================================================================
+// Reducer
+// =============================================================================
+
+export function appReducer(state: AppState, action: Action): AppState {
+  switch (action.type) {
+    case 'SET_STATUS':
+      return { ...state, status: action.status }
+
+    case 'SET_ERROR':
+      return { ...state, error: action.error }
+
+    case 'SET_CWD':
+      return { ...state, currentCwd: action.cwd }
+
+    case 'CWD_CHANGED':
+      return {
+        ...state,
+        currentCwd: action.cwd,
+        messages: [],
+        sessionStats: null,
+        activeToolCalls: new Map(),
+      }
+
+    case 'SET_AUTH_STATUS':
+      return { ...state, authStatus: action.authStatus }
+
+    case 'SET_SESSION_STATE':
+      return { ...state, sessionState: action.sessionState }
+
+    case 'SET_SESSION_STATS':
+      return { ...state, sessionStats: action.sessionStats }
+
+    case 'SET_AVAILABLE_MODELS':
+      return { ...state, availableModels: action.models }
+
+    case 'SET_MESSAGES':
+      return { ...state, messages: action.messages }
+
+    case 'CLEAR_SESSION':
+      return { ...state, messages: [], sessionStats: null }
+
+    case 'RPC_EVENT':
+      return handleRpcEvent(state, action.event)
+
+    default:
+      return state
+  }
+}
+
+// =============================================================================
+// RPC Event Handler - Core state logic following AGENT_SPEC.md
+// =============================================================================
+
+export function handleRpcEvent(state: AppState, event: RpcEvent): AppState {
+  switch (event.type) {
+    // -------------------------------------------------------------------------
+    // Response events
+    // -------------------------------------------------------------------------
+    case 'response': {
+      if (!event.success) return state
+
+      switch (event.command) {
+        case 'get_state':
+          return { ...state, sessionState: event.data as SessionState }
+        case 'get_messages':
+          return { ...state, messages: ((event.data as { messages?: AgentMessage[] })?.messages) || [] }
+        case 'get_available_models':
+          return { ...state, availableModels: ((event.data as { models?: AvailableModel[] })?.models) || [] }
+        case 'get_session_stats':
+          return { ...state, sessionStats: event.data as SessionStats }
+        case 'new_session':
+          return { ...state, messages: [], sessionStats: null }
+        default:
+          return state
+      }
+    }
+
+    // -------------------------------------------------------------------------
+    // Agent lifecycle events
+    // -------------------------------------------------------------------------
+    case 'agent_start':
+      return {
+        ...state,
+        isStreaming: true,
+        activeToolCalls: new Map(),
+      }
+
+    case 'agent_end':
+      return {
+        ...state,
+        isStreaming: false,
+        activeToolCalls: new Map(),
+        streamingMessageIndex: null,
+      }
+
+    // -------------------------------------------------------------------------
+    // Message events - Build messages incrementally
+    // -------------------------------------------------------------------------
+    case 'message_start': {
+      const msg = event.message
+      const newMessages = [...state.messages, msg]
+      let newState: AppState = {
+        ...state,
+        messages: newMessages,
+      }
+
+      // If assistant message, track streaming index
+      if (msg.role === 'assistant') {
+        newState.streamingMessageIndex = newMessages.length - 1
+      }
+
+      // If toolResult arrives, remove from activeToolCalls (it's now in messages)
+      if (msg.role === 'toolResult') {
+        const toolCallId = (msg as ToolResultMessage).toolCallId
+        const newActiveToolCalls = new Map(state.activeToolCalls)
+        newActiveToolCalls.delete(toolCallId)
+        newState.activeToolCalls = newActiveToolCalls
+      }
+
+      return newState
+    }
+
+    case 'message_update': {
+      const msg = event.message
+      if (state.messages.length === 0) {
+        return { ...state, messages: [msg] }
+      }
+      const updated = [...state.messages]
+      updated[updated.length - 1] = msg
+      return { ...state, messages: updated }
+    }
+
+    case 'message_end':
+      return { ...state, streamingMessageIndex: null }
+
+    // -------------------------------------------------------------------------
+    // Tool execution events - Track for progress indicators
+    // -------------------------------------------------------------------------
+    case 'tool_execution_start': {
+      const newActiveToolCalls = new Map(state.activeToolCalls)
+      newActiveToolCalls.set(event.toolCallId, {
+        toolCallId: event.toolCallId,
+        toolName: event.toolName,
+        args: event.args || {},
+        status: 'running',
+        partialOutput: null,
+      })
+      return { ...state, activeToolCalls: newActiveToolCalls }
+    }
+
+    case 'tool_execution_update': {
+      const existing = state.activeToolCalls.get(event.toolCallId)
+      if (!existing) return state
+
+      const text = event.partialResult?.content?.find((c): c is { type: 'text'; text: string } => c.type === 'text')?.text
+      const newActiveToolCalls = new Map(state.activeToolCalls)
+      newActiveToolCalls.set(event.toolCallId, {
+        ...existing,
+        partialOutput: text || null,
+      })
+      return { ...state, activeToolCalls: newActiveToolCalls }
+    }
+
+    case 'tool_execution_end': {
+      const existing = state.activeToolCalls.get(event.toolCallId)
+      if (!existing) return state
+
+      const text = event.result?.content?.find((c): c is { type: 'text'; text: string } => c.type === 'text')?.text
+      const newActiveToolCalls = new Map(state.activeToolCalls)
+      newActiveToolCalls.set(event.toolCallId, {
+        ...existing,
+        status: event.isError ? 'error' : 'done',
+        partialOutput: text || null,
+      })
+      return { ...state, activeToolCalls: newActiveToolCalls }
+    }
+
+    default:
+      return state
+  }
+}