snow-ai 0.3.2 → 0.3.3

package/dist/agents/summaryAgent.d.ts

@@ -0,0 +1,31 @@
+export declare class SummaryAgent {
+    private modelName;
+    private requestMethod;
+    private initialized;
+    /**
+     * Initialize the summary agent with current configuration
+     * @returns true if initialized successfully, false otherwise
+     */
+    private initialize;
+    /**
+     * Check if summary agent is available
+     */
+    isAvailable(): Promise<boolean>;
+    /**
+     * Call the basic model with the same routing as main flow
+     * Uses streaming APIs and intercepts to assemble complete response
+     * This ensures 100% consistency with main flow routing
+     * @param messages - Chat messages
+     * @param abortSignal - Optional abort signal to cancel the request
+     */
+    private callBasicModel;
+    /**
+     * Generate a concise summary from the first user message
+     *
+     * @param userMessage - The first user message in the conversation
+     * @param abortSignal - Optional abort signal to cancel generation
+     * @returns A concise summary (10-20 words) suitable for session title
+     */
+    generateSummary(userMessage: string, abortSignal?: AbortSignal): Promise<string>;
+}
+export declare const summaryAgent: SummaryAgent;

package/dist/agents/summaryAgent.js

@@ -0,0 +1,256 @@
+import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
+import { logger } from '../utils/logger.js';
+import { createStreamingChatCompletion } from '../api/chat.js';
+import { createStreamingResponse } from '../api/responses.js';
+import { createStreamingGeminiCompletion } from '../api/gemini.js';
+import { createStreamingAnthropicCompletion } from '../api/anthropic.js';
+export class SummaryAgent {
+    constructor() {
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ''
+        });
+        Object.defineProperty(this, "requestMethod", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'chat'
+        });
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    /**
+     * Initialize the summary agent with current configuration
+     * @returns true if initialized successfully, false otherwise
+     */
+    async initialize() {
+        try {
+            const config = getOpenAiConfig();
+            // Check if basic model is configured
+            if (!config.basicModel) {
+                return false;
+            }
+            this.modelName = config.basicModel;
+            this.requestMethod = config.requestMethod; // Follow main flow's request method
+            this.initialized = true;
+            return true;
+        }
+        catch (error) {
+            logger.warn('Failed to initialize summary agent:', error);
+            return false;
+        }
+    }
+    /**
+     * Check if summary agent is available
+     */
+    async isAvailable() {
+        if (!this.initialized) {
+            return await this.initialize();
+        }
+        return true;
+    }
+    /**
+     * Call the basic model with the same routing as main flow
+     * Uses streaming APIs and intercepts to assemble complete response
+     * This ensures 100% consistency with main flow routing
+     * @param messages - Chat messages
+     * @param abortSignal - Optional abort signal to cancel the request
+     */
+    async callBasicModel(messages, abortSignal) {
+        const config = getOpenAiConfig();
+        if (!config.basicModel) {
+            throw new Error('Basic model not configured');
+        }
+        // Get custom system prompt if configured
+        const customSystemPrompt = getCustomSystemPrompt();
+        // If custom system prompt exists, prepend it to messages
+        // This ensures summary agent respects user's custom system configuration
+        let processedMessages = messages;
+        if (customSystemPrompt) {
+            processedMessages = [
+                {
+                    role: 'system',
+                    content: customSystemPrompt,
+                },
+                ...messages,
+            ];
+        }
+        // Temporarily override advancedModel with basicModel
+        const originalAdvancedModel = config.advancedModel;
+        try {
+            // Override config to use basicModel
+            config.advancedModel = config.basicModel;
+            let streamGenerator;
+            // Route to appropriate streaming API based on request method (follows main flow exactly)
+            switch (this.requestMethod) {
+                case 'anthropic':
+                    streamGenerator = createStreamingAnthropicCompletion({
+                        model: this.modelName,
+                        messages: processedMessages,
+                        max_tokens: 1024, // Summaries are short
+                    }, abortSignal);
+                    break;
+                case 'gemini':
+                    streamGenerator = createStreamingGeminiCompletion({
+                        model: this.modelName,
+                        messages: processedMessages,
+                    }, abortSignal);
+                    break;
+                case 'responses':
+                    streamGenerator = createStreamingResponse({
+                        model: this.modelName,
+                        messages: processedMessages,
+                        stream: true,
+                    }, abortSignal);
+                    break;
+                case 'chat':
+                default:
+                    streamGenerator = createStreamingChatCompletion({
+                        model: this.modelName,
+                        messages: processedMessages,
+                        stream: true,
+                    }, abortSignal);
+                    break;
+            }
+            // Intercept streaming response and assemble complete content
+            let completeContent = '';
+            let chunkCount = 0;
+            try {
+                for await (const chunk of streamGenerator) {
+                    chunkCount++;
+                    // Check abort signal
+                    if (abortSignal?.aborted) {
+                        throw new Error('Request aborted');
+                    }
+                    // Handle different chunk formats based on request method
+                    if (this.requestMethod === 'chat') {
+                        // Chat API uses standard OpenAI format: {choices: [{delta: {content}}]}
+                        if (chunk.choices && chunk.choices[0]?.delta?.content) {
+                            completeContent += chunk.choices[0].delta.content;
+                        }
+                    }
+                    else {
+                        // Responses, Gemini, and Anthropic APIs all use: {type: 'content', content: string}
+                        if (chunk.type === 'content' && chunk.content) {
+                            completeContent += chunk.content;
+                        }
+                    }
+                }
+            }
+            catch (streamError) {
+                // Log streaming error with details
+                if (streamError instanceof Error) {
+                    logger.error('Summary agent: Streaming error:', {
+                        error: streamError.message,
+                        stack: streamError.stack,
+                        name: streamError.name,
+                        chunkCount,
+                        contentLength: completeContent.length,
+                    });
+                }
+                else {
+                    logger.error('Summary agent: Unknown streaming error:', {
+                        error: streamError,
+                        chunkCount,
+                        contentLength: completeContent.length,
+                    });
+                }
+                throw streamError;
+            }
+            return completeContent;
+        }
+        catch (error) {
+            // Log detailed error from API call setup or streaming
+            if (error instanceof Error) {
+                logger.error('Summary agent: API call failed:', {
+                    error: error.message,
+                    stack: error.stack,
+                    name: error.name,
+                    requestMethod: this.requestMethod,
+                    modelName: this.modelName,
+                });
+            }
+            else {
+                logger.error('Summary agent: Unknown API error:', {
+                    error,
+                    requestMethod: this.requestMethod,
+                    modelName: this.modelName,
+                });
+            }
+            throw error;
+        }
+        finally {
+            // Restore original config
+            config.advancedModel = originalAdvancedModel;
+        }
+    }
+    /**
+     * Generate a concise summary from the first user message
+     *
+     * @param userMessage - The first user message in the conversation
+     * @param abortSignal - Optional abort signal to cancel generation
+     * @returns A concise summary (10-20 words) suitable for session title
+     */
+    async generateSummary(userMessage, abortSignal) {
+        const available = await this.isAvailable();
+        if (!available) {
+            // If summary agent is not available, return a truncated version of the message
+            return userMessage.slice(0, 50) + (userMessage.length > 50 ? '...' : '');
+        }
+        try {
+            const summaryPrompt = `Generate a concise summary (10-20 words) for the following user message. The summary should capture the main topic or intent.
+
+User Message: ${userMessage}
+
+Instructions:
+1. Keep it under 20 words
+2. Focus on the main topic or question
+3. Use clear, simple language
+4. Do not include quotes or special formatting
+5. Make it suitable as a conversation title
+
+Summary:`;
+            const messages = [
+                {
+                    role: 'user',
+                    content: summaryPrompt,
+                },
+            ];
+            const summary = await this.callBasicModel(messages, abortSignal);
+            if (!summary || summary.trim().length === 0) {
+                logger.warn('Summary agent returned empty response, using truncated message');
+                return (userMessage.slice(0, 50) + (userMessage.length > 50 ? '...' : ''));
+            }
+            // Clean up the summary (remove quotes, trim whitespace)
+            const cleanedSummary = summary
+                .trim()
+                .replace(/^["']|["']$/g, '') // Remove leading/trailing quotes
+                .replace(/\n/g, ' ') // Replace newlines with spaces
+                .slice(0, 100); // Limit to 100 characters max
+            return cleanedSummary;
+        }
+        catch (error) {
+            // Log detailed error information
+            if (error instanceof Error) {
+                logger.warn('Summary agent generation failed, using truncated message:', {
+                    error: error.message,
+                    stack: error.stack,
+                    name: error.name,
+                });
+            }
+            else {
+                logger.warn('Summary agent generation failed with unknown error:', error);
+            }
+            // Fallback to truncated message
+            return userMessage.slice(0, 50) + (userMessage.length > 50 ? '...' : '');
+        }
+    }
+}
+// Export singleton instance
+export const summaryAgent = new SummaryAgent();

package/dist/hooks/useSessionSave.js

@@ -2,9 +2,20 @@ import { useCallback, useRef } from 'react';
 import { sessionManager } from '../utils/sessionManager.js';
 export function useSessionSave() {
     const savedMessagesRef = useRef(new Set());
-    // Generate a unique ID for a message (based on role + content + timestamp window)
+    // Generate a unique ID for a message (based on role + content + timestamp window + tool identifiers)
     const generateMessageId = useCallback((message, timestamp) => {
-        return `${message.role}-${message.content.length}-${Math.floor(timestamp / 5000)}`;
+        // Base ID with role, content length, and time window
+        let id = `${message.role}-${message.content.length}-${Math.floor(timestamp / 5000)}`;
+        // For assistant messages with tool_calls, include tool call IDs to ensure uniqueness
+        if (message.role === 'assistant' && message.tool_calls && message.tool_calls.length > 0) {
+            const toolCallIds = message.tool_calls.map(tc => tc.id).sort().join(',');
+            id += `-tools:${toolCallIds}`;
+        }
+        // For tool result messages, include the tool_call_id to ensure uniqueness
+        if (message.role === 'tool' && message.tool_call_id) {
+            id += `-toolcall:${message.tool_call_id}`;
+        }
+        return id;
     }, []);
     // Save API message directly - 直接保存 API 格式的消息
     const saveMessage = useCallback(async (message) => {

package/dist/ui/pages/ChatScreen.js

@@ -674,11 +674,18 @@ export default function ChatScreen({ skipWelcome }) {
             .filter(m => m.toolPending)
             .map((message, index) => (React.createElement(Box, { key: `pending-tool-${index}`, marginBottom: 1, paddingX: 1, width: terminalWidth },
             React.createElement(Text, { color: "yellowBright", bold: true }, "\u2746"),
-            React.createElement(Box, { marginLeft: 1, marginBottom: 1, flexDirection: "row" },
-                React.createElement(MarkdownRenderer, { content: message.content || ' ', color: "yellow" }),
-                React.createElement(Box, { marginLeft: 1 },
-                    React.createElement(Text, { color: "yellow" },
-                        React.createElement(Spinner, { type: "dots" }))))))),
+            React.createElement(Box, { marginLeft: 1, marginBottom: 1, flexDirection: "column" },
+                React.createElement(Box, { flexDirection: "row" },
+                    React.createElement(MarkdownRenderer, { content: message.content || ' ', color: "yellow" }),
+                    React.createElement(Box, { marginLeft: 1 },
+                        React.createElement(Text, { color: "yellow" },
+                            React.createElement(Spinner, { type: "dots" })))),
+                message.toolDisplay && message.toolDisplay.args.length > 0 && (React.createElement(Box, { flexDirection: "column", marginTop: 1 }, message.toolDisplay.args.map((arg, argIndex) => (React.createElement(Text, { key: argIndex, color: "gray", dimColor: true },
+                    arg.isLast ? '└─' : '├─',
+                    " ",
+                    arg.key,
+                    ": ",
+                    arg.value))))))))),
         (streamingState.isStreaming || isSaving) && !pendingToolConfirmation && (React.createElement(Box, { marginBottom: 1, paddingX: 1, width: terminalWidth },
             React.createElement(Text, { color: ['#FF6EBF', 'green', 'blue', 'cyan', '#B588F8'][streamingState.animationFrame], bold: true }, "\u2746"),
             React.createElement(Box, { marginLeft: 1, marginBottom: 1, flexDirection: "column" }, streamingState.isStreaming ? (React.createElement(React.Fragment, null, streamingState.retryStatus &&

package/dist/utils/sessionManager.d.ts

@@ -22,9 +22,16 @@ export interface SessionListItem {
 declare class SessionManager {
     private readonly sessionsDir;
     private currentSession;
+    private summaryAbortController;
+    private summaryTimeoutId;
     constructor();
     private ensureSessionsDir;
     private getSessionPath;
+    /**
+     * Cancel any ongoing summary generation
+     * This prevents wasted resources and race conditions
+     */
+    private cancelOngoingSummaryGeneration;
     createNewSession(): Promise<Session>;
     saveSession(session: Session): Promise<void>;
     loadSession(sessionId: string): Promise<Session | null>;

package/dist/utils/sessionManager.js

@@ -2,6 +2,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
 import { randomUUID } from 'crypto';
+import { summaryAgent } from '../agents/summaryAgent.js';
 class SessionManager {
     constructor() {
         Object.defineProperty(this, "sessionsDir", {
@@ -16,6 +17,18 @@ class SessionManager {
             writable: true,
             value: null
         });
+        Object.defineProperty(this, "summaryAbortController", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "summaryTimeoutId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
         this.sessionsDir = path.join(os.homedir(), '.snow', 'sessions');
     }
     async ensureSessionsDir() {
@@ -29,6 +42,20 @@ class SessionManager {
     getSessionPath(sessionId) {
         return path.join(this.sessionsDir, `${sessionId}.json`);
     }
+    /**
+     * Cancel any ongoing summary generation
+     * This prevents wasted resources and race conditions
+     */
+    cancelOngoingSummaryGeneration() {
+        if (this.summaryAbortController) {
+            this.summaryAbortController.abort();
+            this.summaryAbortController = null;
+        }
+        if (this.summaryTimeoutId) {
+            clearTimeout(this.summaryTimeoutId);
+            this.summaryTimeoutId = null;
+        }
+    }
     async createNewSession() {
         await this.ensureSessionsDir();
         // 使用 UUID v4 生成唯一会话 ID，避免并发冲突
@@ -40,7 +67,7 @@ class SessionManager {
             createdAt: Date.now(),
             updatedAt: Date.now(),
             messages: [],
-            messageCount: 0
+            messageCount: 0,
         };
         this.currentSession = session;
         await this.saveSession(session);
@@ -80,7 +107,7 @@ class SessionManager {
                             summary: session.summary,
                             createdAt: session.createdAt,
                             updatedAt: session.updatedAt,
-                            messageCount: session.messageCount
+                            messageCount: session.messageCount,
                         });
                     }
                     catch (error) {
@@ -142,10 +169,59 @@ class SessionManager {
         this.currentSession.messages.push(message);
         this.currentSession.messageCount = this.currentSession.messages.length;
         this.currentSession.updatedAt = Date.now();
-        // Simple title generation from first user message (no API call)
+        // Generate summary from first user message using summaryAgent (parallel, non-blocking)
         if (this.currentSession.messageCount === 1 && message.role === 'user') {
+            // Set temporary title immediately (synchronous)
             this.currentSession.title = message.content.slice(0, 50);
             this.currentSession.summary = message.content.slice(0, 100);
+            // Cancel any previous summary generation (防呆机制)
+            this.cancelOngoingSummaryGeneration();
+            // Create new AbortController for this summary generation
+            this.summaryAbortController = new AbortController();
+            const currentSessionId = this.currentSession.id;
+            const abortSignal = this.summaryAbortController.signal;
+            // Set timeout to cancel summary generation after 30 seconds (防呆机制)
+            this.summaryTimeoutId = setTimeout(() => {
+                if (this.summaryAbortController) {
+                    console.warn('Summary generation timeout after 30s, aborting...');
+                    this.summaryAbortController.abort();
+                    this.summaryAbortController = null;
+                }
+            }, 30000);
+            // Generate better summary in parallel (non-blocking)
+            // This won't delay the main conversation flow
+            summaryAgent
+                .generateSummary(message.content, abortSignal)
+                .then(summary => {
+                // 防呆检查：确保会话没有被切换，且仍然是第一条消息
+                if (this.currentSession &&
+                    this.currentSession.id === currentSessionId &&
+                    this.currentSession.messageCount === 1) {
+                    // Only update if this is still the first message in the same session
+                    this.currentSession.title = summary;
+                    this.currentSession.summary = summary;
+                    this.saveSession(this.currentSession).catch(error => {
+                        console.error('Failed to save session with generated summary:', error);
+                    });
+                }
+                // Clean up
+                this.cancelOngoingSummaryGeneration();
+            })
+                .catch(error => {
+                // Clean up on error
+                this.cancelOngoingSummaryGeneration();
+                // Silently fail if aborted (expected behavior)
+                if (error.name === 'AbortError' || abortSignal.aborted) {
+                    console.log('Summary generation cancelled (expected)');
+                    return;
+                }
+                // Log other errors - we already have a fallback title/summary
+                console.warn('Summary generation failed, using fallback:', error);
+            });
+        }
+        else if (this.currentSession.messageCount > 1) {
+            // 防呆机制：如果不是第一条消息，取消任何正在进行的摘要生成
+            this.cancelOngoingSummaryGeneration();
         }
         await this.saveSession(this.currentSession);
     }
@@ -153,9 +229,13 @@ class SessionManager {
         return this.currentSession;
     }
     setCurrentSession(session) {
+        // 防呆机制：切换会话时取消正在进行的摘要生成
+        this.cancelOngoingSummaryGeneration();
         this.currentSession = session;
     }
     clearCurrentSession() {
+        // 防呆机制：清除会话时取消正在进行的摘要生成
+        this.cancelOngoingSummaryGeneration();
         this.currentSession = null;
     }
     async deleteSession(sessionId) {

package/package.json

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

package/readme.md

@@ -6,97 +6,118 @@
 
 **English** | [中文](readme_zh.md)
 
-*An intelligent AI-powered CLI tool for developers*
+_An intelligent AI-powered CLI tool for developers_
 
 </div>
 
 ---
 
-
-## Install
+## Installation
 
 ```bash
-$ npm install --global snow-ai
+$ npm install -g snow-ai
 ```
 
-## Start
-```bash
-$ snow
-```
+You can also clone and build from source: https://github.com/MayDay-wpf/snow-cli
 
-## Update
-```bash
-$ snow --update
-```
+### Install VSCode Extension
 
-## Config example  `./User/.snow/config.json`
-```json
-{
-  "snowcfg": {
-    "baseUrl": "https://api.openai.com/v1",//Gemini：https://generativelanguage.googleapis.com Anthropic：https://api.anthropic.com
-    "apiKey": "your-api-key",
-    "requestMethod": "responses",
-    "advancedModel": "gpt-5-codex",
-    "basicModel": "gpt-5-codex",
-    "maxContextTokens": 32000, //The maximum context length of the model
-    "maxTokens": 4096, // The maximum generation length of the model
-    "anthropicBeta": false,
-    "compactModel": {
-      "baseUrl": "https://api.opeai.com/v1",
-      "apiKey": "your-api-key",
-      "modelName": "gpt-4.1-mini"
-    }
-  }
-}
-```
+- Download [VSIX/snow-cli-x.x.x.vsix](https://github.com/MayDay-wpf/snow-cli/blob/main/VSIX/)
 
-## Uninstall
-```bash
-$ npm uninstall --global snow-ai
-```
+- Open VSCode, click `Extensions` -> `Install from VSIX...` -> select `snow-cli-0.2.6.vsix`
 
-## Install VSCode Extension
+### Install JetBrains Plugin
 
-* download [VSIX/snow-cli-x.x.x.vsix](https://github.com/MayDay-wpf/snow-cli/blob/main/VSIX/)
+- Download [JetBrains/build/distributions](https://github.com/MayDay-wpf/snow-cli/tree/main/JetBrains/build/distributions)
 
-* open VSCode, click `Extensions` -> `Install from VSIX...` -> select `snow-cli-0.2.6.vsix`
+## Available Commands
 
-## Install JetBrains plugin
+- **Start**: `$ snow`
+- **Update**: `$ snow --update`
+- **Version**: `$ snow --version`
+- **Resume**: `$ snow -c` - Restore the latest conversation history (fully compatible with Claude Code)
 
-* download [JetBrains/build/distributions](https://github.com/MayDay-wpf/snow-cli/tree/main/JetBrains/build/distributions)
+## API & Model Settings
 
-* File > Settings > Plugins
+In version `v0.3.2` and later, all official SDKs have been removed (they were too heavy), so the configuration is slightly different. After starting, enter `API & Model Settings` to see the following options:
 
-## Live View
-* **Welcome & Settings**
+- **Profile** - Switch or create new configurations. Snow now supports saving multiple API and model schemes
+- **Base URL** - Request endpoint. Since official SDKs were removed, OpenAI and Anthropic require `/v1` suffix, Gemini requires `/v1beta`
+- **API Key** - Your API key
+- **Request Method** - Choose based on your needs: `Chat Completions`, `Responses`, `Gemini`, or `Anthropic`
+- **Anthropic Beta** - When checked, Anthropic requests will automatically include `beta=true` parameter
+- **Advanced Model**, **Basic Model**, **Compact Model** - Set the high-performance model for tasks, small model for summarization, and compact model for context compression. All three models use the configured `BaseURL` and `API Key`. The system automatically fetches available models from the `/models` endpoint with filtering support. For APIs with incomplete model lists, use `Manual Input (Enter model name)` to specify the model name
+- **Max Context Tokens** - The model's maximum context window, used for calculating context percentage. For example, Gemini typically has 1M context, so enter `1000000`. This parameter only affects UI calculations, not actual model context
+- **Max Tokens** - This is critical and will be directly added to API requests as the `max_tokens` parameter
 
 ![alt text](image.png)
 
-* **Agent**
+## Proxy & Browser Settings
+
+Configure system proxy port and search engine for web search. In most cases, this doesn't need modification as the app will automatically use system proxy. The app automatically detects available search engines (Edge/Chrome) unless you've manually changed their installation paths.
 
 ![alt text](image-1.png)
-* In the middle of the conversation: click ESC to stop AI generation
 
-* When mounting: double-click ESC, view the dialogue recorder, select rollback, including file checkpoints
+## System Prompt Settings
 
-* MacOS:`ctrl + v` Paste image
-* Windows:`alt + v` Paste image
+Customize your system prompt. Note that this supplements Snow's built-in system prompt rather than replacing it. When you set a custom system prompt, Snow's default prompt is downgraded to a user message and appended to the first user message. On Windows, the app automatically opens Notepad; on macOS/Linux, it uses the system's default terminal text editor. After editing and saving, Snow will close and prompt you to restart: `Custom system prompt saved successfully! Please use 'snow' to restart!`
 
+## Custom Headers Settings
 
-* **Commands**
+Add custom request headers. Note that you can only add headers, not override Snow's built-in headers.
+
+## MCP Settings
+
+Configure MCP services. The method is identical to setting system prompts, and the JSON format matches Cursor's format.
+
+## Getting Started - Start Conversation
+
+Once everything is configured, enter the conversation page by clicking `Start`.
+
+- If you launch Snow from VSCode or other editors, Snow will automatically connect to the IDE using the `Snow CLI` plugin. You'll see a connection message. The plugins are published online - search for `Snow CLI` in the plugin marketplace to install.
 
 ![alt text](image-2.png)
-  - /clear - Create a new session
 
-  - /resume - The recovery history has
+### File Selection & Commands
+
+- Use `@` to select files. In VSCode, you can also hold `Shift` and drag files for the same effect
+- Use `/` to view available commands:
+  - `/init` - Build project documentation `SNOW.md`
+  - `/clear` - Create a new session
+  - `/resume` - Restore conversation history
+  - `/mcp` - Check MCP connection status and reconnect
+  - `/yolo` - Unattended mode (all tool calls execute without confirmation - use with caution)
+  - `/ide` - Manually connect to IDE (usually automatic if plugin is installed)
+  - `/compact` - Compress context (rarely used as compression reduces AI quality)
+
+### Keyboard Shortcuts
+
+- **Windows**: `Alt+V` - Paste image; **macOS/Linux**: `Ctrl+V` - Paste image (with prompt)
+- `Ctrl+L` - Clear input from cursor position to the left
+- `Ctrl+R` - Clear input from cursor position to the right
+- `Shift+Tab` - Toggle Yolo mode on/off
+- `ESC` - Stop AI generation
+- **Double-click `ESC`** - Rollback conversation (with file checkpoints)
+
+### Token Usage
 
-  - /mcp - Check the status of MCP service
+The input area displays context usage percentage, token count, cache hit tokens, and cache creation tokens.
 
-  - /yolo - Unattended mode, all tools automatically agree to execute
+![alt text](image-3.png)
 
-  - /init - Initialize the project and generate the SNOW.md description document
+## Snow System Files
 
-  - /ide - Connect to VSCode, you need to install the plug-in
+All Snow files are stored in the `.snow` folder in your user directory. Here's what each file/folder contains:
 
-  - /compact - compress the context into a sentence
+![alt text](image-4.png)
 
+- **log** - Runtime logs (not uploaded anywhere, kept locally for debugging). Safe to delete
+- **profiles** - Multiple configuration files for switching between different API/model setups
+- **sessions** - All conversation history (required for `/resume` and other features, not uploaded)
+- **snapshots** - File snapshots before AI edits (used for rollback). Automatic management, no manual intervention needed
+- **todo** - Persisted todo lists from each conversation (prevents AI from forgetting tasks if app exits unexpectedly)
+- **active-profile.txt** - Identifies the currently active profile (for backward compatibility with early versions)
+- **config.json** - Main API configuration file
+- **custom-headers.json** - Custom request headers
+- **mcp-config.json** - MCP service configuration
+- **system-prompt.txt** - Custom system prompt content