aegiscode 3.1.8 → 3.1.10

package/src/store/slices/commandSlice.ts

@@ -0,0 +1,115 @@
+/**
+ * Command Slice - 命令状态管理
+ */
+
+import type { StateCreator } from 'zustand';
+import type { ClawdStore, CommandSlice } from '../types.js';
+
+const initialCommandState = {
+  isProcessing: false,
+  abortController: null as AbortController | null,
+  pendingCommands: [] as string[],
+};
+
+export const createCommandSlice: StateCreator<
+  ClawdStore,
+  [],
+  [],
+  CommandSlice
+> = (set, get) => ({
+  ...initialCommandState,
+
+  actions: {
+    /**
+     * 
+     */
+    setProcessing: (isProcessing: boolean) => {
+      set((state) => ({
+        command: { ...state.command, isProcessing },
+      }));
+    },
+
+    /**
+     * 
+     */
+    createAbortController: () => {
+      const controller = new AbortController();
+      set((state) => ({
+        command: { ...state.command, abortController: controller },
+      }));
+      return controller;
+    },
+
+    /**
+     * 
+     * - 发送 abort signal
+     * - 重置 isProcessing
+     * - 重置 isThinking (跨 slice)
+     * - 清空待处理队列
+     */
+    abort: () => {
+      const { abortController } = get().command;
+
+      if (abortController && !abortController.signal.aborted) {
+        abortController.abort();
+      }
+
+      // 重置 session 的 isThinking 状
+      get().session.actions.setThinking(false);
+
+      // 重置 command 状态并清空队
+      set((state) => ({
+        command: {
+          ...state.command,
+          isProcessing: false,
+          abortController: null,
+          pendingCommands: [],
+        },
+      }));
+    },
+
+    /**
+     * 
+     */
+    enqueueCommand: (command: string) => {
+      set((state) => ({
+        command: {
+          ...state.command,
+          pendingCommands: [...state.command.pendingCommands, command],
+        },
+      }));
+    },
+
+    /**
+     * 
+     */
+    dequeueCommand: () => {
+      const { pendingCommands } = get().command;
+      if (pendingCommands.length === 0) {
+        return undefined;
+      }
+
+      const [nextCommand, ...rest] = pendingCommands;
+      set((state) => ({
+        command: {
+          ...state.command,
+          pendingCommands: rest,
+        },
+      }));
+
+      return nextCommand;
+    },
+
+    /**
+     * 
+     */
+    clearQueue: () => {
+      set((state) => ({
+        command: {
+          ...state.command,
+          pendingCommands: [],
+        },
+      }));
+    },
+  },
+});

package/src/store/slices/configSlice.ts

@@ -0,0 +1,46 @@
+/**
+ * Config Slice - 配置状态管理
+ */
+
+import type { StateCreator } from 'zustand';
+import type { ClawdStore, ConfigSlice } from '../types.js';
+import type { RuntimeConfig } from '../../config/types.js';
+
+export const createConfigSlice: StateCreator<
+  ClawdStore,
+  [],
+  [],
+  ConfigSlice
+> = (set) => ({
+  config: null,
+
+  actions: {
+    /**
+     * 
+     */
+    setConfig: (config: RuntimeConfig) => {
+      set((state) => ({
+        config: { ...state.config, config },
+      }));
+    },
+
+    /**
+     * 
+     */
+    updateConfig: (partial: Partial<RuntimeConfig>) => {
+      set((state) => {
+        if (!state.config.config) {
+          console.warn('[ConfigSlice] Config not initialized, cannot update');
+          return state;
+        }
+
+        return {
+          config: {
+            ...state.config,
+            config: { ...state.config.config, ...partial },
+          },
+        };
+      });
+    },
+  },
+});

package/src/store/slices/focusSlice.ts

@@ -0,0 +1,64 @@
+/**
+ * Focus Slice - 焦点状态管理
+ */
+
+import type { StateCreator } from 'zustand';
+import type { ClawdStore, FocusSlice, FocusId } from '../types.js';
+
+const initialFocusState = {
+  currentFocus: 'input' as FocusId,
+  previousFocus: null as FocusId | null,
+};
+
+export const createFocusSlice: StateCreator<
+  ClawdStore,
+  [],
+  [],
+  FocusSlice
+> = (set, get) => ({
+  ...initialFocusState,
+
+  actions: {
+    /**
+     * 
+     */
+    setFocus: (focus: FocusId) => {
+      set((state) => ({
+        focus: {
+          ...state.focus,
+          previousFocus: state.focus.currentFocus,
+          currentFocus: focus,
+        },
+      }));
+    },
+
+    /**
+     * 
+     */
+    restoreFocus: () => {
+      const { previousFocus } = get().focus;
+      if (previousFocus) {
+        set((state) => ({
+          focus: {
+            ...state.focus,
+            currentFocus: previousFocus,
+            previousFocus: null,
+          },
+        }));
+      }
+    },
+
+    /**
+     * 
+     */
+    pushFocus: (focus: FocusId) => {
+      set((state) => ({
+        focus: {
+          ...state.focus,
+          previousFocus: state.focus.currentFocus,
+          currentFocus: focus,
+        },
+      }));
+    },
+  },
+});

package/src/store/slices/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Store Slices 导出
+ */
+
+export { createSessionSlice } from './sessionSlice.js';
+export { createConfigSlice } from './configSlice.js';
+export { createAppSlice } from './appSlice.js';
+export { createFocusSlice } from './focusSlice.js';
+export { createCommandSlice } from './commandSlice.js';

package/src/store/slices/sessionSlice.ts

@@ -0,0 +1,424 @@
+/**
+ * Session Slice - 会话状态管理
+ *
+ * Streaming Architecture (Buffer + Store):
+ *
+ * During streaming, content deltas arrive at high frequency (per-character).
+ * Writing each delta to the zustand store triggers cascading re-renders
+ * across ALL subscribers — causing visible terminal "blink".
+ *
+ * Solution: External mutable buffer (streaming-buffer.ts).
+ *   - deltas → appendToBuffer() — O(1), no store update
+ *   - MessageList RAF loop polls buffer directly — only MessageList re-renders
+ *   - Store updated only at: start, flush (tool calls), finish
+ *
+ * flushStreamBuffer → drainBuffer() → store.set() → initStreamingBuffer()
+ *   Used mid-streaming (e.g., before a tool call) to persist content to store
+ *   while keeping the buffer alive for subsequent deltas.
+ *
+ * finishStreamingMessage → drainBuffer() → store.set() (isStreaming=false)
+ *   Finalizes the message. No re-init — streaming is done.
+ */
+
+import type { StateCreator } from 'zustand';
+import type { ClawdStore, SessionSlice, SessionMessage, TokenUsage, ContentBlock, ToolCallStatus } from '../types.js';
+import { appendToBuffer, appendThinkingToBuffer, initStreamingBuffer, drainBuffer, clearBuffer } from '../streaming-buffer.js';
+
+const generateId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+
+// Mutable buffer for in-progress tool inputs.
+// updateToolCallInput accumulates here without touching the store;
+// setToolCallInput flushes the final value in a single set() call.
+const _toolInputBuffer = new Map<string, string>(); // toolCallId → partial JSON
+
+const initialSessionState = {
+  sessionId: generateId(),
+  messages: [] as SessionMessage[],
+  isThinking: false,
+  isCompacting: false,
+  currentCommand: null as string | null,
+  error: null as string | null,
+  isActive: true,
+  tokenUsage: {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    maxContextTokens: 200000,
+    modelBreakdown: {},
+  } as TokenUsage,
+};
+
+export const createSessionSlice: StateCreator<
+  ClawdStore,
+  [],
+  [],
+  SessionSlice
+> = (set, get) => ({
+  ...initialSessionState,
+
+  actions: {
+    /**
+     * Append a fully-formed message (no streaming).
+     */
+    addMessage: (message: SessionMessage) => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          messages: [...state.session.messages, message],
+          error: null,
+        },
+      }));
+    },
+
+    /**
+     * Create and append a user message from plain text.
+     */
+    addUserMessage: (content: string) => {
+      const message: SessionMessage = {
+        id: `user-${generateId()}`,
+        role: 'user',
+        content,
+        timestamp: Date.now(),
+      };
+      get().session.actions.addMessage(message);
+    },
+
+    /**
+     * Create and append a fully-formed assistant message.
+     */
+    addAssistantMessage: (content: string) => {
+      const message: SessionMessage = {
+        id: `assistant-${generateId()}`,
+        role: 'assistant',
+        content,
+        timestamp: Date.now(),
+      };
+      get().session.actions.addMessage(message);
+    },
+
+    /**
+     * Start a new streaming assistant message.
+     * Creates an empty placeholder in the store and initializes the buffer.
+     * Returns the message ID for subsequent delta/flush/finish calls.
+     */
+    startStreamingMessage: () => {
+      const id = `assistant-${generateId()}`;
+      const message: SessionMessage = {
+        id,
+        role: 'assistant',
+        content: '',
+        thinking: '',
+        timestamp: Date.now(),
+        isStreaming: true,
+      };
+      set((state) => ({
+        session: {
+          ...state.session,
+          messages: [...state.session.messages, message],
+          error: null,
+        },
+      }));
+      initStreamingBuffer(id);
+      return id;
+    },
+
+    /**
+     * Append content delta to the mutable buffer ONLY.
+     * No store update — the RAF loop picks up content from the buffer.
+     */
+    appendToStreamingMessage: (_id: string, contentDelta: string) => {
+      appendToBuffer(contentDelta);
+    },
+
+    /**
+     * Append thinking delta to the mutable buffer ONLY.
+     * No store update — same reasoning as appendToStreamingMessage.
+     */
+    appendThinkingToStreamingMessage: (_id: string, thinkingDelta: string) => {
+      if (thinkingDelta) {
+        appendThinkingToBuffer(thinkingDelta);
+      }
+    },
+
+    /**
+     * Force-flush buffer content to the store, then re-init the buffer.
+     *
+     * Used before tool calls so preceding text is persisted to the message
+     * while the buffer stays alive for tool call arguments and subsequent text.
+     *
+     * drainBuffer() atomically reads + clears the buffer (but keeps messageId).
+     * Then initStreamingBuffer() re-initializes with the same ID so
+     * isActiveStreamingMessage() still resolves correctly.
+     */
+    flushStreamBuffer: (id: string) => {
+      const drained = drainBuffer();
+      if (!drained || (!drained.content && !drained.thinking && drained.toolCalls.length === 0)) return;
+
+      set((state) => ({
+        session: {
+          ...state.session,
+          messages: state.session.messages.map(msg =>
+            msg.id === id
+              ? {
+                  ...msg,
+                  content: msg.content + drained.content,
+                  thinking: (msg.thinking || '') + drained.thinking,
+                }
+              : msg
+          ),
+        },
+      }));
+
+      // Re-init so subsequent deltas are tracked under the same message ID.
+      initStreamingBuffer(id);
+    },
+
+    /**
+     * Write directly to the store message, bypassing the buffer.
+     * Used for immediate content (errors, forced updates) during streaming.
+     */
+    forceAppendToMessage: (id: string, contentDelta: string) => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          messages: state.session.messages.map(msg =>
+            msg.id === id
+              ? { ...msg, content: msg.content + contentDelta }
+              : msg
+          ),
+        },
+      }));
+    },
+
+    /**
+     * Finalize streaming: drain buffer to store, mark message as complete.
+     *
+     * drainBuffer() reads and clears the buffer atomically. The content
+     * is appended to the store message and isStreaming is set to false.
+     * The RAF loop stops polling this message (isStreaming check fails).
+     *
+     * No re-init needed — streaming is done.
+     */
+    finishStreamingMessage: (id: string) => {
+      const drained = drainBuffer();
+      // Clear messageId so getStreamingContent() returns null immediately.
+      // Without this, the stale React state window sees a non-null buffer
+      // and keeps rendering the streaming cursor.
+      clearBuffer();
+
+      set((state) => ({
+        session: {
+          ...state.session,
+          messages: state.session.messages.map(msg =>
+            msg.id === id
+              ? {
+                  ...msg,
+                  content: msg.content + (drained ? drained.content : ''),
+                  thinking: (msg.thinking || '') + (drained ? drained.thinking : ''),
+                  isStreaming: false,
+                }
+              : msg
+          ),
+        },
+      }));
+    },
+
+    // ===== Content Block Operations =====
+
+    addContentBlock: (messageId: string, block: ContentBlock) => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          messages: state.session.messages.map(msg =>
+            msg.id === messageId
+              ? {
+                  ...msg,
+                  contentBlocks: [...(msg.contentBlocks || []), block],
+                }
+              : msg
+          ),
+        },
+      }));
+    },
+
+    updateToolCallInput: (_messageId: string, toolCallId: string, partialJson: string) => {
+      // Accumulate in mutable buffer only — no store update per character.
+      // setToolCallInput flushes the final value in a single set() call.
+      _toolInputBuffer.set(toolCallId, (_toolInputBuffer.get(toolCallId) ?? '') + partialJson);
+    },
+
+    setToolCallInput: (messageId: string, toolCallId: string, fullInput: string) => {
+      _toolInputBuffer.delete(toolCallId);
+      set((state) => ({
+        session: {
+          ...state.session,
+          messages: state.session.messages.map(msg =>
+            msg.id === messageId && msg.contentBlocks
+              ? {
+                  ...msg,
+                  contentBlocks: msg.contentBlocks.map(block =>
+                    block.type === 'tool_use' && block.id === toolCallId
+                      ? { ...block, input: fullInput } as ContentBlock
+                      : block
+                  ),
+                }
+              : msg
+          ),
+        },
+      }));
+    },
+
+    updateToolCallStatus: (messageId: string, toolCallId: string, status: ToolCallStatus, completedAt?: number) => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          messages: state.session.messages.map(msg =>
+            msg.id === messageId && msg.contentBlocks
+              ? {
+                  ...msg,
+                  contentBlocks: msg.contentBlocks.map(block =>
+                    block.type === 'tool_use' && block.id === toolCallId
+                      ? { ...block, status, ...(completedAt ? { completedAt } : {}) } as ContentBlock
+                      : block
+                  ),
+                }
+              : msg
+          ),
+        },
+      }));
+    },
+
+    addToolResultBlock: (messageId: string, toolUseId: string, content: string, isError: boolean) => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          messages: state.session.messages.map(msg =>
+            msg.id === messageId
+              ? {
+                  ...msg,
+                  contentBlocks: [
+                    ...(msg.contentBlocks || []),
+                    { type: 'tool_result', tool_use_id: toolUseId, content, is_error: isError } as ContentBlock,
+                  ],
+                }
+              : msg
+          ),
+        },
+      }));
+    },
+
+    /**
+     * Set thinking state indicator.
+     */
+    setThinking: (isThinking: boolean) => {
+      set((state) => ({
+        session: { ...state.session, isThinking },
+      }));
+    },
+
+    /**
+     * Set compacting indicator (context compaction in progress).
+     */
+    setCompacting: (isCompacting: boolean) => {
+      set((state) => ({
+        session: { ...state.session, isCompacting },
+      }));
+    },
+
+    /**
+     * Set the current command being processed.
+     */
+    setCurrentCommand: (command: string | null) => {
+      set((state) => ({
+        session: { ...state.session, currentCommand: command },
+      }));
+    },
+
+    /**
+     * Set error state.
+     */
+    setError: (error: string | null) => {
+      set((state) => ({
+        session: { ...state.session, error },
+      }));
+    },
+
+    /**
+     * Set session ID.
+     */
+    setSessionId: (sessionId: string) => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          sessionId,
+        },
+      }));
+    },
+
+    /**
+     * Restore a session with messages from persistence.
+     */
+    restoreSession: (sessionId: string, messages: SessionMessage[]) => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          sessionId,
+          messages,
+          error: null,
+          isActive: true,
+        },
+      }));
+    },
+
+    /**
+     * Update token usage counters.
+     */
+    updateTokenUsage: (usage: Partial<TokenUsage>) => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          tokenUsage: { ...state.session.tokenUsage, ...usage },
+        },
+      }));
+    },
+
+    /**
+     * Remove the last N messages from the store.
+     * Used to rollback messages added before discovering a selector result.
+     */
+    removeLastMessages: (count: number) => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          messages: state.session.messages.slice(0, -count),
+        },
+      }));
+    },
+
+    /**
+     * Clear all messages (new session within same session ID).
+     */
+    clearMessages: () => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          messages: [],
+          error: null,
+        },
+      }));
+    },
+
+    /**
+     * Full session reset with a new session ID.
+     */
+    resetSession: () => {
+      set((state) => ({
+        session: {
+          ...state.session,
+          ...initialSessionState,
+          sessionId: generateId(),
+        },
+      }));
+    },
+  },
+});