snow-ai 0.3.27 → 0.3.28

package/dist/api/systemPrompt.js

@@ -195,9 +195,10 @@ Guidance and recommendations:
 
 ## 📚 Project Context (SNOW.md)
 
-- Read ONLY when implementing large features or unfamiliar architecture
-- Skip for simple tasks where you understand the structure
-- Contains: project overview, architecture, tech stack
+- Contains: project overview, architecture, tech stack.
+- Generally located in the project root directory.
+- You can read this file at any time to understand the project and recommend reading.
+- This file may not exist. If you can't find it, please ignore it.
 
 Remember: **ACTION > ANALYSIS**. Write code first, investigate only when blocked.`;
 // Export SYSTEM_PROMPT as a getter function for real-time ROLE.md updates

package/dist/hooks/useCommandHandler.js

@@ -27,6 +27,7 @@ export async function executeContextCompression() {
             tool_calls: msg.tool_calls,
             images: msg.images,
             reasoning: msg.reasoning,
+            thinking: msg.thinking, // 保留 thinking 字段（Anthropic Extended Thinking）
             subAgentInternal: msg.subAgentInternal,
         }));
         // Compress the context (全量压缩，保留最后一轮完整对话)
@@ -38,10 +39,10 @@ export async function executeContextCompression() {
         }
         // 构建新的会话消息列表
         const newSessionMessages = [];
-        // 添加压缩摘要到会话
+        // 添加压缩摘要到会话（使用 user 角色，因为 Extended Thinking 模式下所有 assistant 消息都需要 thinking 块）
         newSessionMessages.push({
-            role: 'assistant',
-            content: compressionResult.summary,
+            role: 'user',
+            content: `[Context Summary from Previous Conversation]\n\n${compressionResult.summary}`,
             timestamp: Date.now(),
         });
         // 添加保留的最后一轮完整对话（保留完整的消息结构）
@@ -57,6 +58,7 @@ export async function executeContextCompression() {
                     ...(msg.tool_calls && { tool_calls: msg.tool_calls }),
                     ...(msg.images && { images: msg.images }),
                     ...(msg.reasoning && { reasoning: msg.reasoning }),
+                    ...(msg.thinking && { thinking: msg.thinking }), // 保留 thinking 字段（Anthropic Extended Thinking）
                     ...(msg.subAgentInternal !== undefined && {
                         subAgentInternal: msg.subAgentInternal,
                     }),

package/dist/hooks/useConversation.js

@@ -327,6 +327,10 @@ export async function handleConversationWithTools(options) {
                     ]);
                 }
                 // Display tool calls in UI - 只有耗时工具才显示进行中状态
+                // Generate parallel group ID when there are multiple tools
+                const parallelGroupId = receivedToolCalls.length > 1
+                    ? `parallel-${Date.now()}-${Math.random()}`
+                    : undefined;
                 for (const toolCall of receivedToolCalls) {
                     const toolDisplay = formatToolCallMessage(toolCall);
                     let toolArgs;
@@ -351,6 +355,8 @@ export async function handleConversationWithTools(options) {
                                 toolDisplay,
                                 toolCallId: toolCall.id, // Store tool call ID for later update
                                 toolPending: true, // Mark as pending execution
+                                // Mark parallel group for ALL tools (time-consuming or not)
+                                parallelGroup: parallelGroupId,
                             },
                         ]);
                     }
@@ -724,6 +730,8 @@ export async function handleConversationWithTools(options) {
                     m.toolResult !== undefined ||
                     m.subAgentInternal === true));
                 // Update existing tool call messages with results
+                // Collect all result messages first, then add them in batch
+                const resultMessages = [];
                 for (const result of toolResults) {
                     const toolCall = receivedToolCalls.find(tc => tc.id === result.tool_call_id);
                     if (toolCall) {
@@ -733,17 +741,13 @@ export async function handleConversationWithTools(options) {
                             const isError = result.content.startsWith('Error:');
                             const statusIcon = isError ? '✗' : '✓';
                             const statusText = isError ? `\n  └─ ${result.content}` : '';
-                            // Display subagent completion message in main flow
-                            setMessages(prev => [
-                                ...prev,
-                                {
-                                    role: 'assistant',
-                                    content: `${statusIcon} ${toolCall.function.name}${statusText}`,
-                                    streaming: false,
-                                    // Pass the full result.content for ToolResultPreview to parse
-                                    toolResult: !isError ? result.content : undefined,
-                                },
-                            ]);
+                            resultMessages.push({
+                                role: 'assistant',
+                                content: `${statusIcon} ${toolCall.function.name}${statusText}`,
+                                streaming: false,
+                                // Pass the full result.content for ToolResultPreview to parse
+                                toolResult: !isError ? result.content : undefined,
+                            });
                             // Save the tool result to conversation history
                             conversationMessages.push(result);
                             saveMessage(result).catch(error => {
@@ -790,27 +794,24 @@ export async function handleConversationWithTools(options) {
                         // - 普通工具(单步显示):完成消息需要包含参数和结果，使用 toolDisplay
                         // 获取工具参数的格式化信息
                         const toolDisplay = formatToolCallMessage(toolCall);
-                        setMessages(prev => [
-                            ...prev,
-                            // Add new completed message
-                            {
-                                role: 'assistant',
-                                content: `${statusIcon} ${toolCall.function.name}${statusText}`,
-                                streaming: false,
-                                toolCall: editDiffData
-                                    ? {
-                                        name: toolCall.function.name,
-                                        arguments: editDiffData,
-                                    }
-                                    : undefined,
-                                // 为普通工具添加参数显示（耗时工具在进行中状态已经显示过参数）
-                                toolDisplay: !isToolNeedTwoStepDisplay(toolCall.function.name)
-                                    ? toolDisplay
-                                    : undefined,
-                                // Store tool result for preview rendering
-                                toolResult: !isError ? result.content : undefined,
-                            },
-                        ]);
+                        const isNonTimeConsuming = !isToolNeedTwoStepDisplay(toolCall.function.name);
+                        resultMessages.push({
+                            role: 'assistant',
+                            content: `${statusIcon} ${toolCall.function.name}${statusText}`,
+                            streaming: false,
+                            toolCall: editDiffData
+                                ? {
+                                    name: toolCall.function.name,
+                                    arguments: editDiffData,
+                                }
+                                : undefined,
+                            // 为普通工具添加参数显示（耗时工具在进行中状态已经显示过参数）
+                            toolDisplay: isNonTimeConsuming ? toolDisplay : undefined,
+                            // Store tool result for preview rendering
+                            toolResult: !isError ? result.content : undefined,
+                            // Mark parallel group for ALL tools (time-consuming or not)
+                            parallelGroup: parallelGroupId,
+                        });
                     }
                     // Add tool result to conversation history and save (skip if already saved above)
                     if (toolCall && !toolCall.function.name.startsWith('subagent-')) {
@@ -820,6 +821,10 @@ export async function handleConversationWithTools(options) {
                         });
                     }
                 }
+                // Add all result messages in batch to avoid intermediate renders
+                if (resultMessages.length > 0) {
+                    setMessages(prev => [...prev, ...resultMessages]);
+                }
                 // Check if there are pending user messages to insert
                 if (options.getPendingMessages && options.clearPendingMessages) {
                     const pendingMessages = options.getPendingMessages();

package/dist/ui/components/MessageList.d.ts

@@ -39,6 +39,7 @@ export interface Message {
         isComplete?: boolean;
     };
     subAgentInternal?: boolean;
+    parallelGroup?: string;
 }
 interface Props {
     messages: Message[];

package/dist/ui/pages/ChatScreen.js

@@ -913,6 +913,35 @@ export default function ChatScreen({ skipWelcome }) {
                     let toolStatusColor = 'cyan';
                     let isToolMessage = false;
                     const isLastMessage = index === filteredMessages.length - 1;
+                    // Check if this message is part of a parallel group
+                    const isInParallelGroup = message.parallelGroup !== undefined &&
+                        message.parallelGroup !== null;
+                    // Check if this is a time-consuming tool (has toolPending or starts with ⚡)
+                    // Time-consuming tools should not show parallel group indicators
+                    const isTimeConsumingTool = message.toolPending ||
+                        (message.role === 'assistant' &&
+                            (message.content.startsWith('⚡') ||
+                                message.content.includes('⚇⚡')));
+                    // Only show parallel group indicators for non-time-consuming tools
+                    const shouldShowParallelIndicator = isInParallelGroup && !isTimeConsumingTool;
+                    const isFirstInGroup = shouldShowParallelIndicator &&
+                        (index === 0 ||
+                            filteredMessages[index - 1]?.parallelGroup !==
+                                message.parallelGroup ||
+                            // Previous message is time-consuming tool, so this is the first non-time-consuming one
+                            filteredMessages[index - 1]?.toolPending ||
+                            filteredMessages[index - 1]?.content.startsWith('⚡'));
+                    // Check if this is the last message in the parallel group
+                    // Only show end indicator if:
+                    // 1. This is truly the last message, OR
+                    // 2. Next message has a DIFFERENT non-null parallelGroup (not just undefined)
+                    const nextMessage = filteredMessages[index + 1];
+                    const nextHasDifferentGroup = nextMessage &&
+                        nextMessage.parallelGroup !== undefined &&
+                        nextMessage.parallelGroup !== null &&
+                        nextMessage.parallelGroup !== message.parallelGroup;
+                    const isLastInGroup = shouldShowParallelIndicator &&
+                        (!nextMessage || nextHasDifferentGroup);
                     if (message.role === 'assistant' || message.role === 'subagent') {
                         if (message.content.startsWith('⚡') ||
                             message.content.includes('⚇⚡')) {
@@ -934,17 +963,23 @@ export default function ChatScreen({ skipWelcome }) {
                                 message.role === 'subagent' ? 'magenta' : 'blue';
                         }
                     }
-                    return (React.createElement(Box, { key: `msg-${index}`, marginTop: index > 0 ? 1 : 0, marginBottom: isLastMessage ? 1 : 0, paddingX: 1, flexDirection: "column", width: terminalWidth },
+                    return (React.createElement(Box, { key: `msg-${index}`, marginTop: index > 0 && !shouldShowParallelIndicator ? 1 : 0, marginBottom: isLastMessage ? 1 : 0, paddingX: 1, flexDirection: "column", width: terminalWidth },
+                        isFirstInGroup && (React.createElement(Box, { marginBottom: 0 },
+                            React.createElement(Text, { color: "#FF6EBF", dimColor: true }, "\u250C\u2500 Parallel execution"))),
                         React.createElement(Box, null,
                             React.createElement(Text, { color: message.role === 'user'
                                     ? 'green'
                                     : message.role === 'command'
                                         ? 'gray'
-                                        : toolStatusColor, bold: true }, message.role === 'user'
-                                ? '⛇'
-                                : message.role === 'command'
-                                    ? '⌘'
-                                    : '❆'),
+                                        : toolStatusColor, bold: true },
+                                shouldShowParallelIndicator && !isFirstInGroup
+                                    ? '│'
+                                    : '',
+                                message.role === 'user'
+                                    ? '⛇'
+                                    : message.role === 'command'
+                                        ? '⌘'
+                                        : '❆'),
                             React.createElement(Box, { marginLeft: 1, flexDirection: "column" }, message.role === 'command' ? (React.createElement(React.Fragment, null,
                                 React.createElement(Text, { color: "gray", dimColor: true },
                                     "\u2514\u2500 ",
@@ -1022,7 +1057,9 @@ export default function ChatScreen({ skipWelcome }) {
                                     "\u2514\u2500 [image #",
                                     imageIndex + 1,
                                     "]"))))),
-                                message.discontinued && (React.createElement(Text, { color: "red", bold: true }, "\u2514\u2500 user discontinue"))))))));
+                                message.discontinued && (React.createElement(Text, { color: "red", bold: true }, "\u2514\u2500 user discontinue")))))),
+                        isLastInGroup && (React.createElement(Box, { marginTop: 0 },
+                            React.createElement(Text, { color: "#FF6EBF", dimColor: true }, "\u2514\u2500 End parallel execution")))));
                 }),
             ] }, item => item),
         (streamingState.isStreaming || isSaving) && !pendingToolConfirmation && (React.createElement(Box, { marginBottom: 1, paddingX: 1, width: terminalWidth },

package/dist/utils/sessionConverter.js

@@ -103,6 +103,12 @@ export function convertSessionMessagesToUI(sessionMessages) {
             msg.tool_calls &&
             msg.tool_calls.length > 0 &&
             !msg.subAgentInternal) {
+            // Generate parallel group ID for non-time-consuming tools
+            const hasMultipleTools = msg.tool_calls.length > 1;
+            const hasNonTimeConsumingTool = msg.tool_calls.some(tc => !isToolNeedTwoStepDisplay(tc.function.name));
+            const parallelGroupId = hasMultipleTools && hasNonTimeConsumingTool
+                ? `parallel-${i}-${Math.random()}`
+                : undefined;
             for (const toolCall of msg.tool_calls) {
                 // Skip if already processed
                 if (processedToolCalls.has(toolCall.id))
@@ -130,7 +136,15 @@ export function convertSessionMessagesToUI(sessionMessages) {
                         toolDisplay,
                     });
                 }
-                processedToolCalls.add(toolCall.id);
+                // Store parallel group info for this tool call
+                if (parallelGroupId && !needTwoSteps) {
+                    processedToolCalls.add(toolCall.id);
+                    // Mark this tool call with parallel group (will be used when processing tool results)
+                    toolCall.parallelGroupId = parallelGroupId;
+                }
+                else {
+                    processedToolCalls.add(toolCall.id);
+                }
             }
             continue;
         }
@@ -219,6 +233,23 @@ export function convertSessionMessagesToUI(sessionMessages) {
                     }
                 }
             }
+            // Check if this tool result is part of a parallel group
+            let parallelGroupId;
+            for (let j = i - 1; j >= 0; j--) {
+                const prevMsg = sessionMessages[j];
+                if (!prevMsg)
+                    continue;
+                if (prevMsg.role === 'assistant' &&
+                    prevMsg.tool_calls &&
+                    !prevMsg.subAgentInternal) {
+                    const tc = prevMsg.tool_calls.find(t => t.id === msg.tool_call_id);
+                    if (tc) {
+                        parallelGroupId = tc.parallelGroupId;
+                        break;
+                    }
+                }
+            }
+            const isNonTimeConsuming = !isToolNeedTwoStepDisplay(toolName);
             uiMessages.push({
                 role: 'assistant',
                 content: `${statusIcon} ${toolName}${statusText}`,
@@ -231,6 +262,19 @@ export function convertSessionMessagesToUI(sessionMessages) {
                     }
                     : undefined,
                 terminalResult: terminalResultData,
+                // Add toolDisplay for non-time-consuming tools
+                toolDisplay: isNonTimeConsuming && !editDiffData
+                    ? formatToolCallMessage({
+                        id: msg.tool_call_id || '',
+                        type: 'function',
+                        function: {
+                            name: toolName,
+                            arguments: JSON.stringify(toolArgs),
+                        },
+                    })
+                    : undefined,
+                // Mark parallel group for non-time-consuming tools
+                parallelGroup: isNonTimeConsuming && parallelGroupId ? parallelGroupId : undefined,
             });
             continue;
         }

package/dist/utils/toolExecutor.d.ts

@@ -27,6 +27,8 @@ export interface AddToAlwaysApprovedCallback {
  */
 export declare function executeToolCall(toolCall: ToolCall, abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void, onSubAgentMessage?: SubAgentMessageCallback, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean, addToAlwaysApproved?: AddToAlwaysApprovedCallback): Promise<ToolResult>;
 /**
- * Execute multiple tool calls in parallel
+ * Execute multiple tool calls with intelligent sequencing
+ * - Tools modifying the same resource execute sequentially
+ * - Independent tools execute in parallel
  */
 export declare function executeToolCalls(toolCalls: ToolCall[], abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void, onSubAgentMessage?: SubAgentMessageCallback, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean, addToAlwaysApproved?: AddToAlwaysApprovedCallback): Promise<ToolResult[]>;

package/dist/utils/toolExecutor.js

@@ -63,8 +63,96 @@ export async function executeToolCall(toolCall, abortSignal, onTokenUpdate, onSu
     }
 }
 /**
- * Execute multiple tool calls in parallel
+ * Categorize tools by their resource type for proper execution sequencing
+ */
+function getToolResourceType(toolName) {
+    // TODO tools all modify the same TODO file - must be sequential
+    if (toolName === 'todo-create' ||
+        toolName === 'todo-update' ||
+        toolName === 'todo-add' ||
+        toolName === 'todo-delete') {
+        return 'todo-state';
+    }
+    // Terminal commands must be sequential to avoid race conditions
+    // (e.g., npm install -> npm build, port conflicts, file locks)
+    if (toolName === 'terminal-execute') {
+        return 'terminal-execution';
+    }
+    // Each file is a separate resource
+    if (toolName === 'filesystem-edit' ||
+        toolName === 'filesystem-edit_search' ||
+        toolName === 'filesystem-create' ||
+        toolName === 'filesystem-delete') {
+        return 'filesystem'; // Will be further refined by file path
+    }
+    // Other tools are independent
+    return 'independent';
+}
+/**
+ * Get resource identifier for a tool call
+ * Tools modifying the same resource will have the same identifier
+ */
+function getResourceIdentifier(toolCall) {
+    const toolName = toolCall.function.name;
+    const resourceType = getToolResourceType(toolName);
+    if (resourceType === 'todo-state') {
+        return 'todo-state'; // All TODO operations share same resource
+    }
+    if (resourceType === 'terminal-execution') {
+        return 'terminal-execution'; // All terminal commands share same execution context
+    }
+    if (resourceType === 'filesystem') {
+        try {
+            const args = JSON.parse(toolCall.function.arguments);
+            // Support both single file and array of files
+            const filePath = args.filePath;
+            if (typeof filePath === 'string') {
+                return `filesystem:${filePath}`;
+            }
+            else if (Array.isArray(filePath)) {
+                // For batch operations, treat as independent (already handling multiple files)
+                return `filesystem-batch:${toolCall.id}`;
+            }
+        }
+        catch {
+            // Parsing error, treat as independent
+        }
+    }
+    // Each independent tool gets its own unique identifier
+    return `independent:${toolCall.id}`;
+}
+/**
+ * Execute multiple tool calls with intelligent sequencing
+ * - Tools modifying the same resource execute sequentially
+ * - Independent tools execute in parallel
  */
 export async function executeToolCalls(toolCalls, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved) {
-    return Promise.all(toolCalls.map(tc => executeToolCall(tc, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved)));
+    // Group tool calls by their resource identifier
+    const resourceGroups = new Map();
+    for (const toolCall of toolCalls) {
+        const resourceId = getResourceIdentifier(toolCall);
+        const group = resourceGroups.get(resourceId) || [];
+        group.push(toolCall);
+        resourceGroups.set(resourceId, group);
+    }
+    // Execute each resource group sequentially, but execute different groups in parallel
+    const results = await Promise.all(Array.from(resourceGroups.values()).map(async (group) => {
+        // Within the same resource group, execute sequentially
+        const groupResults = [];
+        for (const toolCall of group) {
+            const result = await executeToolCall(toolCall, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved);
+            groupResults.push(result);
+        }
+        return groupResults;
+    }));
+    // Flatten results and restore original order
+    const flatResults = results.flat();
+    const resultMap = new Map(flatResults.map(r => [r.tool_call_id, r]));
+    return toolCalls.map(tc => {
+        const result = resultMap.get(tc.id);
+        if (!result) {
+            throw new Error(`Result not found for tool call ${tc.id}`);
+        }
+        return result;
+    });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.3.27",
+	"version": "0.3.28",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {