aegiscode 3.1.7 → 3.1.10

package/src/store/streaming-buffer.ts

@@ -0,0 +1,425 @@
+/**
+ * Streaming Buffer - external mutable buffer for streaming content.
+ *
+ * This completely bypasses the zustand store during streaming deltas.
+ * Instead of calling set() on every flush (which triggers React re-renders
+ * across all store subscribers), we write directly to a mutable buffer.
+ * The MessageList RAF loop reads from this buffer directly.
+ *
+ * Only start/finish streaming and explicit flushes update the store.
+ *
+ * Supports Content Block model (Claude-style): text, thinking, tool_use, tool_result.
+ */
+
+import type { SessionMessage, ToolCallStatus, ContentBlock } from './types.js';
+import { TranscriptBuffer } from '../services/streaming/TranscriptBuffer.js';
+import { parseStreamEvent } from '../services/streaming/StreamEventParser.js';
+import type { AnthropicStreamEvent } from '../services/streaming/types.js';
+
+// Shared mutable state for the currently streaming message
+interface StreamingState {
+  messageId: string | null;
+  content: string;
+  thinking: string;
+  // Content block tracking
+  currentBlockType: 'text' | 'thinking' | null;
+  currentBlockAccumulator: string;
+  toolCalls: Map<string, { name: string; arguments: string; status: ToolCallStatus }>;
+  /** Canonical rich segment state — single source of truth for streaming content */
+  transcriptBuffer: TranscriptBuffer;
+  /** Maps content block index → tool use ID for input_json_delta accumulation */
+  blockIndexToToolId: Map<number, string>;
+  /** Timestamp of last content write — used to measure render latency */
+  lastWriteTimestamp: number;
+}
+
+const streamingState: StreamingState = {
+  messageId: null,
+  content: '',
+  thinking: '',
+  currentBlockType: null,
+  currentBlockAccumulator: '',
+  toolCalls: new Map(),
+  transcriptBuffer: new TranscriptBuffer({ showToolResults: false }),
+  blockIndexToToolId: new Map(),
+  lastWriteTimestamp: 0,
+};
+
+/**
+ * Check if a message IS the currently active streaming message (by ref).
+ * This is used by the RAF loop to efficiently skip non-streaming messages.
+ */
+export function isActiveStreamingMessage(msg: SessionMessage): boolean {
+  return msg.id === streamingState.messageId;
+}
+
+/**
+ * Get direct reference to current streaming content.
+ * Returns null if no streaming is active.
+ */
+export function getStreamingContent(): { content: string; thinking: string } | null {
+  if (!streamingState.messageId) return null;
+  return {
+    content: streamingState.content,
+    thinking: streamingState.thinking,
+  };
+}
+
+/**
+ * Get streaming content blocks synthesized from the current buffer state.
+ * Returns TextBlock and ThinkingBlock objects representing in-flight content,
+ * plus any accumulated tool_use blocks.
+ *
+ * These are merged with store content blocks in MessageList for structured rendering.
+ */
+export function getStreamingContentBlocks(): ContentBlock[] {
+  const blocks: ContentBlock[] = [];
+
+  if (streamingState.thinking) {
+    blocks.push({ type: 'thinking', thinking: streamingState.thinking });
+  }
+
+  if (streamingState.content) {
+    blocks.push({ type: 'text', text: streamingState.content });
+  }
+
+  return blocks;
+}
+
+/**
+ * Apply a raw Anthropic-format streaming event.
+ *
+ * This is the primary entry point for the main chat path. It feeds the
+ * TranscriptBuffer (rich segment model) and simultaneously updates the
+ * mutable content/thinking strings (for drain/flush compat) and the
+ * toolCalls map (for arg accumulation before store flush).
+ *
+ * Legacy paths (slash commands) continue using appendToBuffer /
+ * appendThinkingToBuffer directly and bypass the TranscriptBuffer.
+ */
+export function applyStreamEvent(event: AnthropicStreamEvent): void {
+  const parsed = parseStreamEvent(event);
+  for (const e of parsed) {
+    streamingState.transcriptBuffer.apply(e);
+
+    if ((e.type === 'text_delta' || e.type === 'text_chunk') && e.text) {
+      streamingState.content += e.text;
+      streamingState.lastWriteTimestamp = Date.now();
+      streamingState.currentBlockType = 'text';
+      streamingState.currentBlockAccumulator += e.text;
+    }
+    if ((e.type === 'thinking_delta' || e.type === 'thinking_chunk') && e.text) {
+      streamingState.thinking += e.text;
+      streamingState.lastWriteTimestamp = Date.now();
+      streamingState.currentBlockType = 'thinking';
+      streamingState.currentBlockAccumulator += e.text;
+    }
+    if (e.type === 'tool_use_start' && e.id && e.name) {
+      if (!streamingState.toolCalls.has(e.id)) {
+        streamingState.toolCalls.set(e.id, { name: e.name, arguments: '', status: 'running' });
+      }
+      if (e.index !== undefined && e.index >= 0) {
+        streamingState.blockIndexToToolId.set(e.index, e.id);
+      }
+    }
+    if (e.type === 'tool_use_delta' && e.partial_json && e.index !== undefined) {
+      const toolId = streamingState.blockIndexToToolId.get(e.index);
+      if (toolId) {
+        const tc = streamingState.toolCalls.get(toolId);
+        if (tc) tc.arguments += e.partial_json;
+      }
+    }
+  }
+}
+
+/**
+ * Initialize buffer for a new streaming message.
+ * When called with the same ID as the current message (flush cycle),
+ * only the content/thinking strings are reset — tool calls are preserved
+ * so arg accumulation survives mid-stream flushes.
+ */
+export function initStreamingBuffer(messageId: string): void {
+  const isNewMessage = streamingState.messageId !== messageId;
+  streamingState.messageId = messageId;
+  streamingState.content = '';
+  streamingState.thinking = '';
+  streamingState.currentBlockType = null;
+  streamingState.currentBlockAccumulator = '';
+  if (isNewMessage) {
+    streamingState.toolCalls.clear();
+    streamingState.transcriptBuffer.clear();
+    streamingState.blockIndexToToolId.clear();
+  }
+}
+
+/**
+ * Append content delta to the mutable buffer (NO store update).
+ * Tracks as 'text' content block if we're in a text block.
+ */
+/**
+ * Get the time (ms) since the last content was written to the buffer.
+ * Returns 0 if no streaming is active.
+ */
+export function getStreamingLatencyMs(): number {
+  if (!streamingState.messageId || streamingState.lastWriteTimestamp === 0) return 0;
+  return Date.now() - streamingState.lastWriteTimestamp;
+}
+
+export function appendToBuffer(contentDelta: string): void {
+  streamingState.content += contentDelta;
+  streamingState.lastWriteTimestamp = Date.now();
+  // Track as text block
+  streamingState.currentBlockType = 'text';
+  streamingState.currentBlockAccumulator += contentDelta;
+}
+
+/**
+ * Append thinking delta to the mutable buffer (NO store update).
+ * Tracks as 'thinking' content block.
+ */
+export function appendThinkingToBuffer(thinkingDelta: string): void {
+  streamingState.thinking += thinkingDelta;
+  streamingState.lastWriteTimestamp = Date.now();
+  streamingState.currentBlockType = 'thinking';
+  streamingState.currentBlockAccumulator += thinkingDelta;
+}
+
+/**
+ * Signal the start of a tool_use block. Records the tool call ID and name.
+ */
+export function startToolCallInBuffer(toolCallId: string, name: string): void {
+  streamingState.toolCalls.set(toolCallId, { name, arguments: '', status: 'running' });
+}
+
+/**
+ * Accumulate tool call arguments JSON delta.
+ */
+export function appendToolCallDelta(toolCallId: string, argumentsDelta: string): void {
+  const existing = streamingState.toolCalls.get(toolCallId);
+  if (existing) {
+    existing.arguments += argumentsDelta;
+  }
+}
+
+/**
+ * Mark a tool call as completed (success or error).
+ */
+export function finishToolCallInBuffer(toolCallId: string, isError: boolean): void {
+  const existing = streamingState.toolCalls.get(toolCallId);
+  if (existing) {
+    existing.status = isError ? 'error' : 'success';
+  }
+}
+
+/**
+ * Get tool calls accumulated in the buffer.
+ */
+export function getBufferedToolCalls(): Array<{ id: string; name: string; arguments: string; status: ToolCallStatus }> {
+  return Array.from(streamingState.toolCalls.entries()).map(([id, tc]) => ({
+    id,
+    ...tc,
+  }));
+}
+
+/**
+ * Clear the buffer (e.g., on error/abort or after finishStreamingMessage).
+ */
+export function clearBuffer(): void {
+  streamingState.messageId = null;
+  streamingState.content = '';
+  streamingState.thinking = '';
+  streamingState.currentBlockType = null;
+  streamingState.currentBlockAccumulator = '';
+  streamingState.toolCalls.clear();
+  streamingState.transcriptBuffer.clear();
+  streamingState.blockIndexToToolId.clear();
+  streamingState.lastWriteTimestamp = 0;
+}
+
+/**
+ * Check if buffer has content.
+ */
+export function hasBufferContent(): boolean {
+  return streamingState.content.length > 0 || streamingState.thinking.length > 0 || streamingState.toolCalls.size > 0;
+}
+
+/**
+ * Peek at current content without clearing.
+ */
+export function peekBuffer(): { content: string; thinking: string; currentBlockType: string | null; currentBlockContent: string; toolCalls: Array<{ id: string; name: string; arguments: string; status: ToolCallStatus }> } {
+  return {
+    content: streamingState.content,
+    thinking: streamingState.thinking,
+    currentBlockType: streamingState.currentBlockType,
+    currentBlockContent: streamingState.currentBlockAccumulator,
+    toolCalls: getBufferedToolCalls(),
+  };
+}
+
+/**
+ * Drain accumulated content block from the buffer.
+ * Returns the block data and resets the accumulator.
+ */
+export function drainContentBlock(): { type: 'text' | 'thinking'; content: string } | null {
+  if (!streamingState.currentBlockType || !streamingState.currentBlockAccumulator) {
+    return null;
+  }
+  const block = {
+    type: streamingState.currentBlockType as 'text' | 'thinking',
+    content: streamingState.currentBlockAccumulator,
+  };
+  streamingState.currentBlockType = null;
+  streamingState.currentBlockAccumulator = '';
+  return block;
+}
+
+/**
+ * Drain tool calls from the buffer.
+ */
+export function drainToolCalls(): Array<{ id: string; name: string; arguments: string; status: ToolCallStatus }> {
+  const calls = getBufferedToolCalls();
+  streamingState.toolCalls.clear();
+  return calls;
+}
+
+/**
+ * Drain ALL content from the buffer and return it.
+ * Clears the buffer entirely. Used by flushStreamBuffer and finishStreamingMessage.
+ *
+ * This is the SINGLE function that removes content from the buffer.
+ * After calling it, the buffer is empty and ready for new content.
+ *
+ * Returns null if buffer is empty (no messageId set or no content).
+ */
+export function drainBuffer(): { content: string; thinking: string; toolCalls: Array<{ id: string; name: string; arguments: string; status: ToolCallStatus }> } | null {
+  if (!streamingState.messageId) return null;
+  if (!streamingState.content && !streamingState.thinking && streamingState.toolCalls.size === 0) return null;
+
+  const result = {
+    content: streamingState.content,
+    thinking: streamingState.thinking,
+    toolCalls: getBufferedToolCalls(),
+  };
+
+  // Clear content but KEEP messageId (so isActiveStreamingMessage still works)
+  // and KEEP toolCalls (they're still in-flight; cleared by clearBuffer after finish).
+  streamingState.content = '';
+  streamingState.thinking = '';
+  streamingState.currentBlockType = null;
+  streamingState.currentBlockAccumulator = '';
+
+  return result;
+}
+
+// ==================== Batch Buffer for Slash Commands ====================
+// Slash commands trigger multiple store updates (addUserMessage, setThinking, addAssistantMessage).
+// Instead of each calling set() individually (causing cascading re-renders), we batch them:
+// 1. Collect all mutations in a pending batch object
+// 2. flushBatch() applies them as a single set() call
+//
+// The MessageList subscription already detects message count changes (see MessageList.tsx:128-133),
+// so a single batch flush triggers exactly ONE re-render for the entire slash command result.
+
+interface BatchUpdate {
+  userMessage?: string;
+  assistantMessage?: string;
+  isThinking?: boolean;
+}
+
+let pendingBatch: BatchUpdate | null = null;
+
+/**
+ * Start collecting mutations into a batch.
+ */
+export function startBatch(): void {
+  pendingBatch = {};
+}
+
+/**
+ * Queue a user message in the current batch.
+ */
+export function batchAddUserMessage(content: string): void {
+  if (pendingBatch) {
+    pendingBatch.userMessage = content;
+  }
+}
+
+/**
+ * Queue an assistant message in the current batch.
+ */
+export function batchAddAssistantMessage(content: string): void {
+  if (pendingBatch) {
+    pendingBatch.assistantMessage = content;
+  }
+}
+
+/**
+ * Queue a thinking state change in the current batch.
+ */
+export function batchSetThinking(isThinking: boolean): void {
+  if (pendingBatch) {
+    pendingBatch.isThinking = isThinking;
+  }
+}
+
+/**
+ * Flush the batch: apply all queued mutations as a single set() call.
+ * Accepts the store instance to avoid circular dependencies in ESM.
+ *
+ * Returns true if any mutations were applied.
+ *
+ * This is equivalent to calling:
+ *   sessionActions().addUserMessage(...) + sessionActions().addAssistantMessage(...) + sessionActions().setThinking(...)
+ * but done as a SINGLE setState call, eliminating cascading re-renders.
+ */
+export function flushBatchWithStore(store: any): boolean {
+  if (!pendingBatch) return false;
+  const batch = pendingBatch;
+  pendingBatch = null;
+
+  const hasUser = batch.userMessage !== undefined;
+  const hasAssistant = batch.assistantMessage !== undefined;
+  const hasThinking = batch.isThinking !== undefined;
+
+  if (!hasUser && !hasAssistant && !hasThinking) return false;
+
+  const current = store.getState().session;
+  const newMessages = [...current.messages];
+  const generateId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+
+  if (hasUser && batch.userMessage) {
+    newMessages.push({
+      id: `user-${generateId()}`,
+      role: 'user' as const,
+      content: batch.userMessage,
+      timestamp: Date.now(),
+    });
+  }
+
+  if (hasAssistant && batch.assistantMessage) {
+    newMessages.push({
+      id: `assistant-${generateId()}`,
+      role: 'assistant' as const,
+      content: batch.assistantMessage,
+      timestamp: Date.now(),
+    });
+  }
+
+  const update: any = { messages: newMessages };
+  if (hasThinking) {
+    update.isThinking = batch.isThinking;
+  }
+
+  store.setState((s: any) => ({
+    session: { ...s.session, ...update },
+  }));
+
+  return true;
+}
+
+/**
+ * Cancel the current batch (e.g., on error before flush).
+ */
+export function cancelBatch(): void {
+  pendingBatch = null;
+}

package/src/store/test.ts

@@ -0,0 +1,296 @@
+/**
+ * Store 模块测试
+ * 
+ * 
+ */
+
+import {
+  vanillaStore,
+  getState,
+  sessionActions,
+  configActions,
+  appActions,
+  focusActions,
+  commandActions,
+  getConfig,
+  ensureStoreInitialized,
+  subscribeToMessages,
+} from './index.js';
+import type { RuntimeConfig } from '../config/types.js';
+
+let testsPassed = 0;
+let testsFailed = 0;
+
+function pass(msg: string) {
+  testsPassed++;
+  console.log(`✅ ${msg}`);
+}
+
+function fail(msg: string, error?: any) {
+  testsFailed++;
+  console.log(`❌ ${msg}`);
+  if (error) console.log(`   错误: ${error}`);
+}
+
+async function runTests() {
+  console.log('='.repeat(60));
+  console.log('Store 模块测试');
+  console.log('='.repeat(60));
+  console.log();
+
+  // ========== 测试 1: Store 实
+  console.log('📝 测试 1: Store 实例');
+  console.log('-'.repeat(40));
+
+  if (vanillaStore && typeof vanillaStore.getState === 'function') {
+    pass('vanillaStore 实例存在');
+  } else {
+    fail('vanillaStore 实例不存在');
+  }
+
+  const state = getState();
+  if (state.session && state.config && state.app && state.focus && state.command) {
+    pass('Store 包含所有 5 个 Slice');
+  } else {
+    fail('Store 缺少 Slice');
+  }
+  console.log();
+
+  // ========== 测
+  console.log('📝 测试 2: Session Slice');
+  console.log('-'.repeat(40));
+
+  const initialSessionId = getState().session.sessionId;
+  if (initialSessionId && typeof initialSessionId === 'string') {
+    pass(`初始 sessionId: ${initialSessionId.slice(0, 20)}...`);
+  } else {
+    fail('sessionId 无效');
+  }
+
+  // 添加消
+  sessionActions().addUserMessage('Hello, test!');
+  const messages = getState().session.messages;
+  if (messages.length === 1 && messages[0].content === 'Hello, test!') {
+    pass('addUserMessage 正常');
+  } else {
+    fail('addUserMessage 失败');
+  }
+
+  // 设
+  sessionActions().setThinking(true);
+  if (getState().session.isThinking === true) {
+    pass('setThinking(true) 正常');
+  } else {
+    fail('setThinking 失败');
+  }
+
+  sessionActions().setThinking(false);
+
+  // 清空消
+  sessionActions().clearMessages();
+  if (getState().session.messages.length === 0) {
+    pass('clearMessages 正常');
+  } else {
+    fail('clearMessages 失败');
+  }
+  console.log();
+
+  // ========== 测
+  console.log('📝 测试 3: Config Slice');
+  console.log('-'.repeat(40));
+
+  // 初始状态 config 
+  if (getConfig() === null) {
+    pass('初始 config 为 null');
+  } else {
+    fail('初始 config 不为 null');
+  }
+
+  // 设置配
+  const testConfig: RuntimeConfig = {
+    default: { model: 'test-model' },
+    theme: 'dark',
+    defaultPermissionMode: 'default',
+  };
+  configActions().setConfig(testConfig);
+
+  if (getConfig()?.default?.model === 'test-model') {
+    pass('setConfig 正常');
+  } else {
+    fail('setConfig 失败');
+  }
+
+  // 更新配
+  configActions().updateConfig({ theme: 'light' });
+  if (getConfig()?.theme === 'light') {
+    pass('updateConfig 正常');
+  } else {
+    fail('updateConfig 失败');
+  }
+  console.log();
+
+  // ========== 测
+  console.log('📝 测试 4: App Slice');
+  console.log('-'.repeat(40));
+
+  if (getState().app.initializationStatus === 'pending') {
+    pass('初始 initializationStatus 为 pending');
+  } else {
+    fail('初始 initializationStatus 不正确');
+  }
+
+  appActions().setInitializationStatus('ready');
+  if (getState().app.initializationStatus === 'ready') {
+    pass('setInitializationStatus 正常');
+  } else {
+    fail('setInitializationStatus 失败');
+  }
+
+  // Todos
+  appActions().addTodo({ id: '1', title: 'Test todo', status: 'pending', createdAt: Date.now() });
+  if (getState().app.todos.length === 1) {
+    pass('addTodo 正常');
+  } else {
+    fail('addTodo 失败');
+  }
+
+  appActions().updateTodo('1', { status: 'completed' });
+  if (getState().app.todos[0].status === 'completed') {
+    pass('updateTodo 正常');
+  } else {
+    fail('updateTodo 失败');
+  }
+
+  appActions().removeTodo('1');
+  if (getState().app.todos.length === 0) {
+    pass('removeTodo 正常');
+  } else {
+    fail('removeTodo 失败');
+  }
+  console.log();
+
+  // ========== 测
+  console.log('📝 测试 5: Focus Slice');
+  console.log('-'.repeat(40));
+
+  if (getState().focus.currentFocus === 'input') {
+    pass('初始焦点为 input');
+  } else {
+    fail('初始焦点不正确');
+  }
+
+  focusActions().setFocus('messages');
+  if (getState().focus.currentFocus === 'messages') {
+    pass('setFocus 正常');
+  } else {
+    fail('setFocus 失败');
+  }
+
+  if (getState().focus.previousFocus === 'input') {
+    pass('previousFocus 记录正确');
+  } else {
+    fail('previousFocus 记录不正确');
+  }
+
+  focusActions().restoreFocus();
+  if (getState().focus.currentFocus === 'input') {
+    pass('restoreFocus 正常');
+  } else {
+    fail('restoreFocus 失败');
+  }
+  console.log();
+
+  // ========== 测
+  console.log('📝 测试 6: Command Slice');
+  console.log('-'.repeat(40));
+
+  if (getState().command.isProcessing === false) {
+    pass('初始 isProcessing 为 false');
+  } else {
+    fail('初始 isProcessing 不正确');
+  }
+
+  commandActions().setProcessing(true);
+  if (getState().command.isProcessing === true) {
+    pass('setProcessing 正常');
+  } else {
+    fail('setProcessing 失败');
+  }
+
+  // 命令队
+  commandActions().enqueueCommand('command1');
+  commandActions().enqueueCommand('command2');
+  if (getState().command.pendingCommands.length === 2) {
+    pass('enqueueCommand 正常');
+  } else {
+    fail('enqueueCommand 失败');
+  }
+
+  const cmd = commandActions().dequeueCommand();
+  if (cmd === 'command1' && getState().command.pendingCommands.length === 1) {
+    pass('dequeueCommand 正常');
+  } else {
+    fail('dequeueCommand 失败');
+  }
+
+  commandActions().clearQueue();
+  if (getState().command.pendingCommands.length === 0) {
+    pass('clearQueue 正常');
+  } else {
+    fail('clearQueue 失败');
+  }
+
+  // AbortController
+  const controller = commandActions().createAbortController();
+  if (controller instanceof AbortController) {
+    pass('createAbortController 正常');
+  } else {
+    fail('createAbortController 失败');
+  }
+
+  commandActions().abort();
+  if (getState().command.isProcessing === false && getState().command.abortController === null) {
+    pass('abort 正常');
+  } else {
+    fail('abort 失败');
+  }
+  console.log();
+
+  // ========== 测试 7: 订阅功
+  console.log('📝 测试 7: 订阅功能');
+  console.log('-'.repeat(40));
+
+  let subscriptionTriggered = false;
+  const unsubscribe = subscribeToMessages((messages) => {
+    subscriptionTriggered = true;
+  });
+
+  sessionActions().addUserMessage('Trigger subscription');
+  
+  // 等待一下让订阅触
+  await new Promise((resolve) => setTimeout(resolve, 10));
+
+  if (subscriptionTriggered) {
+    pass('subscribeToMessages 正常触发');
+  } else {
+    fail('subscribeToMessages 未触发');
+  }
+
+  unsubscribe();
+  console.log();
+
+  // ========== 测试总
+  console.log('='.repeat(60));
+  console.log(`测试完成: ${testsPassed} 通过, ${testsFailed} 失败`);
+  console.log('='.repeat(60));
+
+  if (testsFailed > 0) {
+    process.exit(1);
+  }
+}
+
+// 运行测
+runTests().catch((error) => {
+  console.error('测试出错:', error);
+  process.exit(1);
+});