snow-ai 0.3.23 → 0.3.24

package/dist/hooks/useConversation.d.ts

@@ -12,11 +12,6 @@ export type ConversationHandlerOptions = {
     saveMessage: (message: any) => Promise<void>;
     setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
     setStreamTokenCount: React.Dispatch<React.SetStateAction<number>>;
-    setCurrentTodos: React.Dispatch<React.SetStateAction<Array<{
-        id: string;
-        content: string;
-        status: 'pending' | 'completed';
-    }>>>;
     requestToolConfirmation: (toolCall: ToolCall, batchToolNames?: string, allTools?: ToolCall[]) => Promise<string>;
     isToolAutoApproved: (toolName: string) => boolean;
     addMultipleToAlwaysApproved: (toolNames: string[]) => void;

package/dist/hooks/useConversation.js

@@ -20,7 +20,7 @@ import { shouldAutoCompress, performAutoCompression, } from '../utils/autoCompre
 export async function handleConversationWithTools(options) {
     const { userContent, imageContents, controller, 
     // messages, // No longer used - we load from session instead to get complete history with tool calls
-    saveMessage, setMessages, setStreamTokenCount, setCurrentTodos, requestToolConfirmation, isToolAutoApproved, addMultipleToAlwaysApproved, yoloMode, setContextUsage, setIsReasoning, setRetryStatus, } = options;
+    saveMessage, setMessages, setStreamTokenCount, requestToolConfirmation, isToolAutoApproved, addMultipleToAlwaysApproved, yoloMode, setContextUsage, setIsReasoning, setRetryStatus, } = options;
     // Create a wrapper function for adding single tool to always-approved list
     const addToAlwaysApproved = (toolName) => {
         addMultipleToAlwaysApproved([toolName]);
@@ -33,10 +33,6 @@ export async function handleConversationWithTools(options) {
     const todoService = getTodoService();
     // Get existing TODO list
     const existingTodoList = await todoService.getTodoList(currentSession.id);
-    // Update UI state
-    if (existingTodoList) {
-        setCurrentTodos(existingTodoList.todos);
-    }
     // Collect all MCP tools
     const mcpTools = await collectAllMCPTools();
     // Build conversation history with TODO context as pinned user message
@@ -364,8 +360,28 @@ export async function handleConversationWithTools(options) {
                 const autoApprovedTools = [];
                 for (const toolCall of receivedToolCalls) {
                     // Check both global approved list and session-approved list
-                    if (isToolAutoApproved(toolCall.function.name) ||
-                        sessionApprovedTools.has(toolCall.function.name)) {
+                    const isApproved = isToolAutoApproved(toolCall.function.name) ||
+                        sessionApprovedTools.has(toolCall.function.name);
+                    // Check if this is a sensitive command (terminal-execute with sensitive pattern)
+                    let isSensitiveCommand = false;
+                    if (toolCall.function.name === 'terminal-execute') {
+                        try {
+                            const args = JSON.parse(toolCall.function.arguments);
+                            const { isSensitiveCommand: checkSensitiveCommand } = await import('../utils/sensitiveCommandManager.js').then(m => ({
+                                isSensitiveCommand: m.isSensitiveCommand,
+                            }));
+                            const sensitiveCheck = checkSensitiveCommand(args.command);
+                            isSensitiveCommand = sensitiveCheck.isSensitive;
+                        }
+                        catch {
+                            // If parsing fails, treat as normal command
+                        }
+                    }
+                    // If sensitive command, always require confirmation regardless of approval status
+                    if (isSensitiveCommand) {
+                        toolsNeedingConfirmation.push(toolCall);
+                    }
+                    else if (isApproved) {
                         autoApprovedTools.push(toolCall);
                     }
                     else {
@@ -374,24 +390,79 @@ export async function handleConversationWithTools(options) {
                 }
                 // Request confirmation only once for all tools needing confirmation
                 let approvedTools = [...autoApprovedTools];
-                // In YOLO mode, auto-approve all tools
+                // In YOLO mode, auto-approve all tools EXCEPT sensitive commands
                 if (yoloMode) {
-                    approvedTools.push(...toolsNeedingConfirmation);
+                    // Filter out sensitive commands from auto-approval
+                    const nonSensitiveTools = [];
+                    const sensitiveTools = [];
+                    for (const toolCall of toolsNeedingConfirmation) {
+                        if (toolCall.function.name === 'terminal-execute') {
+                            try {
+                                const args = JSON.parse(toolCall.function.arguments);
+                                const { isSensitiveCommand: checkSensitiveCommand } = await import('../utils/sensitiveCommandManager.js').then(m => ({
+                                    isSensitiveCommand: m.isSensitiveCommand,
+                                }));
+                                const sensitiveCheck = checkSensitiveCommand(args.command);
+                                if (sensitiveCheck.isSensitive) {
+                                    sensitiveTools.push(toolCall);
+                                }
+                                else {
+                                    nonSensitiveTools.push(toolCall);
+                                }
+                            }
+                            catch {
+                                nonSensitiveTools.push(toolCall);
+                            }
+                        }
+                        else {
+                            nonSensitiveTools.push(toolCall);
+                        }
+                    }
+                    approvedTools.push(...nonSensitiveTools);
+                    // If there are sensitive tools, still need confirmation even in YOLO mode
+                    if (sensitiveTools.length > 0) {
+                        const firstTool = sensitiveTools[0];
+                        const allTools = sensitiveTools.length > 1 ? sensitiveTools : undefined;
+                        const confirmation = await requestToolConfirmation(firstTool, undefined, allTools);
+                        if (confirmation === 'reject') {
+                            setMessages(prev => prev.filter(msg => !msg.toolPending));
+                            for (const toolCall of sensitiveTools) {
+                                const rejectionMessage = {
+                                    role: 'tool',
+                                    tool_call_id: toolCall.id,
+                                    content: 'Error: Tool execution rejected by user',
+                                };
+                                conversationMessages.push(rejectionMessage);
+                                saveMessage(rejectionMessage).catch(error => {
+                                    console.error('Failed to save tool rejection message:', error);
+                                });
+                            }
+                            setMessages(prev => [
+                                ...prev,
+                                {
+                                    role: 'assistant',
+                                    content: 'Tool call rejected, session ended',
+                                    streaming: false,
+                                },
+                            ]);
+                            if (options.setIsStreaming) {
+                                options.setIsStreaming(false);
+                            }
+                            freeEncoder();
+                            return { usage: accumulatedUsage };
+                        }
+                        // Approved, add sensitive tools to approved list
+                        approvedTools.push(...sensitiveTools);
+                    }
                 }
                 else if (toolsNeedingConfirmation.length > 0) {
-                    const firstTool = toolsNeedingConfirmation[0]; // Safe: length > 0 guarantees this exists
-                    // Use regular CLI confirmation
-                    // Pass all tools for proper display in confirmation UI
+                    const firstTool = toolsNeedingConfirmation[0];
                     const allTools = toolsNeedingConfirmation.length > 1
                         ? toolsNeedingConfirmation
                         : undefined;
-                    // Use first tool for confirmation UI, but apply result to all
                     const confirmation = await requestToolConfirmation(firstTool, undefined, allTools);
                     if (confirmation === 'reject') {
-                        // Remove pending tool messages
                         setMessages(prev => prev.filter(msg => !msg.toolPending));
-                        // User rejected - need to save tool rejection messages to maintain conversation structure
-                        // Add tool rejection responses for ALL tools that were rejected
                         for (const toolCall of toolsNeedingConfirmation) {
                             const rejectionMessage = {
                                 role: 'tool',
@@ -403,7 +474,6 @@ export async function handleConversationWithTools(options) {
                                 console.error('Failed to save tool rejection message:', error);
                             });
                         }
-                        // User rejected - end conversation
                         setMessages(prev => [
                             ...prev,
                             {
@@ -412,12 +482,11 @@ export async function handleConversationWithTools(options) {
                                 streaming: false,
                             },
                         ]);
-                        // End streaming immediately
                         if (options.setIsStreaming) {
                             options.setIsStreaming(false);
                         }
                         freeEncoder();
-                        return { usage: accumulatedUsage }; // Exit the conversation loop
+                        return { usage: accumulatedUsage };
                     }
                     // If approved_always, add ALL these tools to both global and session-approved sets
                     if (confirmation === 'approve_always') {
@@ -648,18 +717,6 @@ export async function handleConversationWithTools(options) {
                         // 即使压缩失败也继续处理工具结果
                     }
                 }
-                // Check if there are TODO related tool calls, if yes refresh TODO list
-                const hasTodoTools = approvedTools.some(t => t.function.name.startsWith('todo-'));
-                const hasTodoUpdateTools = approvedTools.some(t => t.function.name === 'todo-update');
-                if (hasTodoTools) {
-                    const session = sessionManager.getCurrentSession();
-                    if (session) {
-                        const updatedTodoList = await todoService.getTodoList(session.id);
-                        if (updatedTodoList) {
-                            setCurrentTodos(updatedTodoList.todos);
-                        }
-                    }
-                }
                 // Remove only streaming sub-agent content messages (not tool-related messages)
                 // Keep sub-agent tool call and tool result messages for display
                 setMessages(prev => prev.filter(m => m.role !== 'subagent' ||
@@ -763,18 +820,6 @@ export async function handleConversationWithTools(options) {
                         });
                     }
                 }
-                // After all tool results are processed, show TODO panel if there were todo-update calls
-                if (hasTodoUpdateTools) {
-                    setMessages(prev => [
-                        ...prev,
-                        {
-                            role: 'assistant',
-                            content: '',
-                            streaming: false,
-                            showTodoTree: true,
-                        },
-                    ]);
-                }
                 // Check if there are pending user messages to insert
                 if (options.getPendingMessages && options.clearPendingMessages) {
                     const pendingMessages = options.getPendingMessages();
@@ -817,7 +862,9 @@ export async function handleConversationWithTools(options) {
                         // Clear pending messages
                         options.clearPendingMessages();
                         // Combine multiple pending messages into one
-                        const combinedMessage = pendingMessages.map(m => m.text).join('\n\n');
+                        const combinedMessage = pendingMessages
+                            .map(m => m.text)
+                            .join('\n\n');
                         // Collect all images from pending messages
                         const allPendingImages = pendingMessages
                             .flatMap(m => m.images || [])

package/dist/hooks/useFilePicker.d.ts

@@ -11,7 +11,7 @@ export declare function useFilePicker(buffer: TextBuffer, triggerUpdate: () => v
     setAtSymbolPosition: (_pos: number) => void;
     filteredFileCount: number;
     searchMode: "content" | "file";
-    updateFilePickerState: (text: string, cursorPos: number) => void;
+    updateFilePickerState: (_text: string, cursorPos: number) => void;
     handleFileSelect: (filePath: string) => Promise<void>;
     handleFilteredCountChange: (count: number) => void;
     fileListRef: import("react").RefObject<FileListRef>;

package/dist/hooks/useFilePicker.js

@@ -51,15 +51,19 @@ export function useFilePicker(buffer, triggerUpdate) {
     });
     const fileListRef = useRef(null);
     // Update file picker state
-    const updateFilePickerState = useCallback((text, cursorPos) => {
-        if (!text.includes('@')) {
+    const updateFilePickerState = useCallback((_text, cursorPos) => {
+        // Use display text (with placeholders) instead of full text (expanded)
+        // to ensure cursor position matches text content
+        // Note: _text parameter is ignored, we use buffer.text instead
+        const displayText = buffer.text;
+        if (!displayText.includes('@')) {
             if (state.showFilePicker) {
                 dispatch({ type: 'HIDE' });
             }
             return;
         }
         // Find the last '@' or '@@' symbol before the cursor
-        const beforeCursor = text.slice(0, cursorPos);
+        const beforeCursor = displayText.slice(0, cursorPos);
         // Look for @@ first (content search), then @ (file search)
         let searchMode = 'file';
         let position = -1;
@@ -130,6 +134,7 @@ export function useFilePicker(buffer, triggerUpdate) {
             }
         }
     }, [
+        buffer,
         state.showFilePicker,
         state.fileQuery,
         state.atSymbolPosition,
@@ -138,13 +143,14 @@ export function useFilePicker(buffer, triggerUpdate) {
     // Handle file selection
     const handleFileSelect = useCallback(async (filePath) => {
         if (state.atSymbolPosition !== -1) {
-            const text = buffer.getFullText();
+            // Use display text (with placeholders) for position calculations
+            const displayText = buffer.text;
             const cursorPos = buffer.getCursorPosition();
             // Replace query with selected file path
             // For content search (@@), the filePath already includes line number
             // For file search (@), just the file path
-            const beforeAt = text.slice(0, state.atSymbolPosition);
-            const afterCursor = text.slice(cursorPos);
+            const beforeAt = displayText.slice(0, state.atSymbolPosition);
+            const afterCursor = displayText.slice(cursorPos);
             // Construct the replacement based on search mode
             const prefix = state.searchMode === 'content' ? '@@' : '@';
             const newText = beforeAt + prefix + filePath + ' ' + afterCursor;
@@ -156,7 +162,7 @@ export function useFilePicker(buffer, triggerUpdate) {
             const targetPos = state.atSymbolPosition + insertedLength;
             // Reset cursor to beginning, then move to correct position
             for (let i = 0; i < targetPos; i++) {
-                if (i < buffer.getFullText().length) {
+                if (i < buffer.text.length) {
                     buffer.moveRight();
                 }
             }

package/dist/hooks/useInputBuffer.d.ts

@@ -2,5 +2,5 @@ import { TextBuffer, Viewport } from '../utils/textBuffer.js';
 export declare function useInputBuffer(viewport: Viewport): {
     buffer: TextBuffer;
     triggerUpdate: () => void;
-    forceUpdate: import("react").Dispatch<import("react").SetStateAction<{}>>;
+    forceUpdate: () => void;
 };

package/dist/hooks/useInputBuffer.js

@@ -1,21 +1,36 @@
 import { useState, useCallback, useEffect, useRef } from 'react';
 import { TextBuffer } from '../utils/textBuffer.js';
 export function useInputBuffer(viewport) {
-    const [, forceUpdate] = useState({});
+    const [, setForceUpdateState] = useState({});
     const lastUpdateTime = useRef(0);
-    // Force re-render when buffer changes
-    const triggerUpdate = useCallback(() => {
+    const bufferRef = useRef(null);
+    // Stable forceUpdate function using useRef
+    const forceUpdateRef = useRef(() => {
+        setForceUpdateState({});
+    });
+    // Stable triggerUpdate function using useRef
+    const triggerUpdateRef = useRef(() => {
         const now = Date.now();
         lastUpdateTime.current = now;
-        forceUpdate({});
-    }, []); // 空依赖项确保函数稳定
-    const [buffer] = useState(() => new TextBuffer(viewport, triggerUpdate));
+        forceUpdateRef.current();
+    });
+    // Initialize buffer once
+    if (!bufferRef.current) {
+        bufferRef.current = new TextBuffer(viewport, triggerUpdateRef.current);
+    }
+    const buffer = bufferRef.current;
+    // Expose stable callback functions
+    const forceUpdate = useCallback(() => {
+        forceUpdateRef.current();
+    }, []);
+    const triggerUpdate = useCallback(() => {
+        triggerUpdateRef.current();
+    }, []);
     // Update buffer viewport when viewport changes
     useEffect(() => {
         buffer.updateViewport(viewport);
-        // 直接调用 forceUpdate 而不是 triggerUpdate，避免依赖问题
-        forceUpdate({});
-    }, [viewport.width, viewport.height]); // 移除 buffer 和 triggerUpdate 避免循环依赖
+        forceUpdateRef.current();
+    }, [viewport.width, viewport.height, buffer]);
     // Cleanup buffer on unmount
     useEffect(() => {
         return () => {

package/dist/hooks/useStreamingState.js

@@ -45,7 +45,7 @@ export function useStreamingState() {
     }, [timerStartTime]);
     // Initialize remaining seconds when retry starts
     useEffect(() => {
-        if (!retryStatus || !retryStatus.isRetrying)
+        if (!retryStatus?.isRetrying)
             return;
         if (retryStatus.remainingSeconds !== undefined)
             return;
@@ -56,7 +56,7 @@ export function useStreamingState() {
                 remainingSeconds: Math.ceil(prev.nextDelay / 1000),
             }
             : null);
-    }, [retryStatus?.isRetrying, retryStatus?.nextDelay]);
+    }, [retryStatus?.isRetrying]); // Only depend on isRetrying flag
     // Countdown timer for retry delays
     useEffect(() => {
         if (!retryStatus || !retryStatus.isRetrying)

package/dist/hooks/useVSCodeState.js

@@ -1,26 +1,43 @@
-import { useState, useEffect } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import { vscodeConnection } from '../utils/vscodeConnection.js';
 export function useVSCodeState() {
     const [vscodeConnected, setVscodeConnected] = useState(false);
     const [vscodeConnectionStatus, setVscodeConnectionStatus] = useState('disconnected');
     const [editorContext, setEditorContext] = useState({});
+    // Use ref to track last status without causing re-renders
+    const lastStatusRef = useRef('disconnected');
+    // Use ref to track last editor context to avoid unnecessary updates
+    const lastEditorContextRef = useRef({});
     // Monitor VSCode connection status and editor context
     useEffect(() => {
         const checkConnectionInterval = setInterval(() => {
             const isConnected = vscodeConnection.isConnected();
             setVscodeConnected(isConnected);
             // Update connection status based on actual connection state
-            if (isConnected && vscodeConnectionStatus !== 'connected') {
+            // Use ref to avoid reading from state
+            if (isConnected && lastStatusRef.current !== 'connected') {
+                lastStatusRef.current = 'connected';
                 setVscodeConnectionStatus('connected');
             }
-            else if (!isConnected && vscodeConnectionStatus === 'connected') {
+            else if (!isConnected && lastStatusRef.current === 'connected') {
+                lastStatusRef.current = 'disconnected';
                 setVscodeConnectionStatus('disconnected');
             }
         }, 1000);
         const unsubscribe = vscodeConnection.onContextUpdate(context => {
-            setEditorContext(context);
+            // Only update state if context has actually changed
+            const hasChanged = context.activeFile !== lastEditorContextRef.current.activeFile ||
+                context.selectedText !== lastEditorContextRef.current.selectedText ||
+                context.cursorPosition?.line !== lastEditorContextRef.current.cursorPosition?.line ||
+                context.cursorPosition?.character !== lastEditorContextRef.current.cursorPosition?.character ||
+                context.workspaceFolder !== lastEditorContextRef.current.workspaceFolder;
+            if (hasChanged) {
+                lastEditorContextRef.current = context;
+                setEditorContext(context);
+            }
             // When we receive context, it means connection is successful
-            if (vscodeConnectionStatus !== 'connected') {
+            if (lastStatusRef.current !== 'connected') {
+                lastStatusRef.current = 'connected';
                 setVscodeConnectionStatus('connected');
             }
         });
@@ -28,7 +45,7 @@ export function useVSCodeState() {
             clearInterval(checkConnectionInterval);
             unsubscribe();
         };
-    }, [vscodeConnectionStatus]);
+    }, []); // Remove vscodeConnectionStatus from dependencies
     // Separate effect for handling connecting timeout
     useEffect(() => {
         if (vscodeConnectionStatus !== 'connecting') {

package/dist/mcp/filesystem.js

@@ -1033,7 +1033,7 @@ export const mcpTools = [
     },
     {
         name: 'filesystem-create',
-        description: 'PREFERRED tool for file creation: Create a new file with specified content. More reliable than terminal commands like echo/cat with redirects. Automatically creates parent directories if needed. Terminal commands can be used as a fallback if needed.',
+        description: 'Preferred tool for creating files: Use specified content to create a new file. Before creating the file, you need to determine if the file already exists; if it does, your creation will fail. You should use editing instead of creation, as this tool is more reliable than terminal commands like echo/cat with redirection. If necessary, automatically create the parent directory. If necessary, terminal commands can be used as a fallback.',
         inputSchema: {
             type: 'object',
             properties: {

package/dist/ui/components/ChatInput.js

@@ -1,4 +1,4 @@
-import React, { useCallback, useEffect, useRef } from 'react';
+import React, { useCallback, useEffect, useRef, useMemo } from 'react';
 import { Box, Text } from 'ink';
 import { cpSlice } from '../../utils/textUtils.js';
 import CommandPanel from './CommandPanel.js';
@@ -41,10 +41,10 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
     // Recalculate viewport dimensions to ensure proper resizing
     const uiOverhead = 8;
     const viewportWidth = Math.max(40, terminalWidth - uiOverhead);
-    const viewport = {
+    const viewport = useMemo(() => ({
         width: viewportWidth,
         height: 1,
-    };
+    }), [viewportWidth]); // Memoize viewport to prevent unnecessary re-renders
     // Use input buffer hook
     const { buffer, triggerUpdate, forceUpdate } = useInputBuffer(viewport);
     // Use command panel hook
@@ -169,10 +169,10 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
     useEffect(() => {
         // Use a small delay to ensure the component tree has updated
         const timer = setTimeout(() => {
-            forceUpdate({});
+            forceUpdate();
         }, 10);
         return () => clearTimeout(timer);
-    }, [showFilePicker]);
+    }, [showFilePicker, forceUpdate]);
     // Handle terminal width changes with debounce (like gemini-cli)
     useEffect(() => {
         // Skip on initial mount
@@ -183,17 +183,22 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
         prevTerminalWidthRef.current = terminalWidth;
         // Debounce the re-render to avoid flickering during resize
         const timer = setTimeout(() => {
-            forceUpdate({});
+            forceUpdate();
         }, 100);
         return () => clearTimeout(timer);
-    }, [terminalWidth]);
+    }, [terminalWidth, forceUpdate]);
     // Notify parent of context percentage changes
+    const lastPercentageRef = useRef(0);
     useEffect(() => {
         if (contextUsage && onContextPercentageChange) {
             const percentage = calculateContextPercentage(contextUsage);
-            onContextPercentageChange(percentage);
+            // Only call callback if percentage has actually changed
+            if (percentage !== lastPercentageRef.current) {
+                lastPercentageRef.current = percentage;
+                onContextPercentageChange(percentage);
+            }
         }
-    }, [contextUsage]); // 移除 onContextPercentageChange 避免循环依赖
+    }, [contextUsage, onContextPercentageChange]);
     // Render cursor based on focus state
     const renderCursor = useCallback((char) => {
         if (hasFocus) {

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

@@ -6,7 +6,6 @@ export interface Message {
     streaming?: boolean;
     discontinued?: boolean;
     commandName?: string;
-    showTodoTree?: boolean;
     files?: SelectedFile[];
     images?: Array<{
         type: 'image';

package/dist/ui/components/MessageList.js

@@ -34,8 +34,7 @@ const MessageList = memo(({ messages, animationFrame, maxMessages = 6 }) => {
                 React.createElement(Box, { marginLeft: 2 },
                     React.createElement(Text, { color: "gray" }, message.content || ' ')))) : (React.createElement(React.Fragment, null,
                 message.role === 'user' ? (React.createElement(Text, { color: "gray" }, message.content || ' ')) : (React.createElement(MarkdownRenderer, { content: message.content || ' ' })),
-                (message.files ||
-                    message.images) && (React.createElement(Box, { flexDirection: "column" },
+                (message.files || message.images) && (React.createElement(Box, { flexDirection: "column" },
                     message.files && message.files.length > 0 && (React.createElement(React.Fragment, null, message.files.map((file, fileIndex) => (React.createElement(Text, { key: fileIndex, color: "gray", dimColor: true }, file.isImage
                         ? `└─ [image #{fileIndex + 1}] ${file.path}`
                         : `└─ Read \`${file.path}\`${file.exists

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

@@ -14,5 +14,5 @@ interface Props {
     allTools?: ToolCall[];
     onConfirm: (result: ConfirmationResult) => void;
 }
-export default function ToolConfirmation({ toolName, toolArguments, allTools, onConfirm }: Props): React.JSX.Element;
+export default function ToolConfirmation({ toolName, toolArguments, allTools, onConfirm, }: Props): React.JSX.Element;
 export {};