snow-ai 0.3.28 → 0.3.30

package/dist/api/systemPrompt.js

@@ -72,6 +72,7 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
 2. **ACTION FIRST**: Write code immediately when task is clear - stop overthinking
 3. **Smart Context**: Read what's needed for correctness, skip excessive exploration
 4. **Quality Verification**: run build/test after changes
+5. **NO Documentation Files**: ❌ NEVER create summary .md files after tasks - use \`notebook-add\` for important notes instead
 
 ## 🚀 Execution Strategy - BALANCE ACTION & ANALYSIS
 
@@ -166,6 +167,16 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
   - Requires IDE plugin installed and running
   - Use AFTER code changes to verify quality
 
+**Notebook (Code Memory):**
+- \`notebook-add\` - Record fragile code that new features might break during iteration
+  - 🎯 Core purpose: Prevent new functionality from breaking old functionality
+  - 📝 Record: Bugs that recurred, fragile dependencies, critical constraints
+  - ⚠️ Examples: "validateInput() must run first - broke twice", "null return required by X"
+  - 📌 **IMPORTANT**: Use notebook for documentation, NOT separate .md files
+- \`notebook-query\` - Manual search (rarely needed, auto-shown when reading files)
+  - 🔍 Auto-attached: Last 10 notebooks appear when reading ANY file
+  - 💡 Use before: Adding features that might affect existing behavior
+
 **Web Search:**
 - \`websearch-search\` - Search web for latest docs/solutions
 - \`websearch-fetch\` - Read web page content (always provide userQuery)

package/dist/hooks/useCommandHandler.js

@@ -154,14 +154,9 @@ export function useCommandHandler(options) {
         // Handle /ide command
         if (commandName === 'ide') {
             if (result.success) {
-                // If already connected, set status to connected immediately
-                // Otherwise, set to connecting and wait for VSCode extension
-                if (result.alreadyConnected) {
-                    options.setVscodeConnectionStatus('connected');
-                }
-                else {
-                    options.setVscodeConnectionStatus('connecting');
-                }
+                // Connection successful, set status to connected immediately
+                // The轮询 mechanism will also update the status, but we do it here for immediate feedback
+                options.setVscodeConnectionStatus('connected');
                 // Don't add command message to keep UI clean
             }
             else {

package/dist/hooks/useConversation.js

@@ -515,8 +515,10 @@ export async function handleConversationWithTools(options) {
                         if (subAgentMessage.message.type === 'tool_calls') {
                             const toolCalls = subAgentMessage.message.tool_calls;
                             if (toolCalls && toolCalls.length > 0) {
-                                // Add tool call messages for each tool
-                                const toolMessages = toolCalls.map((toolCall) => {
+                                // Add tool call messages for each tool (only for time-consuming tools)
+                                const toolMessages = toolCalls
+                                    .filter((toolCall) => isToolNeedTwoStepDisplay(toolCall.function.name))
+                                    .map((toolCall) => {
                                     const toolDisplay = formatToolCallMessage(toolCall);
                                     let toolArgs;
                                     try {
@@ -543,16 +545,21 @@ export async function handleConversationWithTools(options) {
                                         },
                                         subAgentInternal: true, // Mark as internal sub-agent message
                                     };
-                                    // Save to session as 'assistant' role for API compatibility
-                                    const sessionMsg = {
-                                        role: 'assistant',
-                                        content: `⚇⚡ ${toolDisplay.toolName}`,
-                                        subAgentInternal: true,
-                                        tool_calls: [toolCall],
-                                    };
-                                    saveMessage(sessionMsg).catch(err => console.error('Failed to save sub-agent tool call:', err));
                                     return uiMsg;
                                 });
+                                // Save all tool calls to session (regardless of display type)
+                                const sessionMsg = {
+                                    role: 'assistant',
+                                    content: toolCalls
+                                        .map((tc) => {
+                                        const display = formatToolCallMessage(tc);
+                                        return `⚇⚡ ${display.toolName}`;
+                                    })
+                                        .join(', '),
+                                    subAgentInternal: true,
+                                    tool_calls: toolCalls,
+                                };
+                                saveMessage(sessionMsg).catch(err => console.error('Failed to save sub-agent tool call:', err));
                                 return [...prev, ...toolMessages];
                             }
                         }

package/dist/hooks/useVSCodeState.js

@@ -23,7 +23,7 @@ export function useVSCodeState() {
                 lastStatusRef.current = 'disconnected';
                 setVscodeConnectionStatus('disconnected');
             }
-        }, 1000);
+        }, 1000); // Check every second
         const unsubscribe = vscodeConnection.onContextUpdate(context => {
             // Only update state if context has actually changed
             const hasChanged = context.activeFile !== lastEditorContextRef.current.activeFile ||
@@ -51,7 +51,7 @@ export function useVSCodeState() {
         if (vscodeConnectionStatus !== 'connecting') {
             return;
         }
-        // Set timeout for connecting state (30 seconds to allow for IDE plugin reconnection)
+        // Set timeout for connecting state (15 seconds to allow for port scanning and connection)
         const connectingTimeout = setTimeout(() => {
             const isConnected = vscodeConnection.isConnected();
             const isClientRunning = vscodeConnection.isClientRunning();
@@ -65,8 +65,9 @@ export function useVSCodeState() {
                     // Client not running - go back to disconnected
                     setVscodeConnectionStatus('disconnected');
                 }
+                lastStatusRef.current = isClientRunning ? 'error' : 'disconnected';
             }
-        }, 30000); // Increased to 30 seconds
+        }, 15000); // 15 seconds: 10s for connection timeout + 5s buffer
         return () => {
             clearTimeout(connectingTimeout);
         };

package/dist/mcp/filesystem.d.ts

@@ -10,8 +10,25 @@ export declare class FilesystemMCPService {
      */
     private readonly prettierSupportedExtensions;
     constructor(basePath?: string);
+    /**
+     * Extract relevant symbol information for a specific line range
+     * This provides context that helps AI make more accurate modifications
+     * @param symbols - All symbols in the file
+     * @param startLine - Start line of the range
+     * @param endLine - End line of the range
+     * @param _totalLines - Total lines in the file (reserved for future use)
+     * @returns Formatted string with relevant symbol information
+     */
+    private extractRelevantSymbols;
+    /**
+     * Get notebook entries for a file
+     * @param filePath - Path to the file
+     * @returns Formatted notebook entries string, or empty if none found
+     */
+    private getNotebookEntries;
     /**
      * Get the content of a file with optional line range
+     * Enhanced with symbol information for better AI context
      * @param filePath - Path to the file (relative to base path or absolute) or array of file paths or array of file config objects
      * @param startLine - Starting line number (1-indexed, inclusive, optional - defaults to 1). Used for single file or as default for array of strings
      * @param endLine - Ending line number (1-indexed, inclusive, optional - defaults to file end). Used for single file or as default for array of strings

package/dist/mcp/filesystem.js

@@ -11,6 +11,10 @@ import { calculateSimilarity, normalizeForDisplay, } from './utils/filesystem/si
 import { analyzeCodeStructure, findSmartContextBoundaries, } from './utils/filesystem/code-analysis.utils.js';
 import { findClosestMatches, generateDiffMessage, } from './utils/filesystem/match-finder.utils.js';
 import { parseEditBySearchParams, parseEditByLineParams, executeBatchOperation, } from './utils/filesystem/batch-operations.utils.js';
+// ACE Code Search utilities for symbol parsing
+import { parseFileSymbols } from './utils/aceCodeSearch/symbol.utils.js';
+// Notebook utilities for automatic note retrieval
+import { queryNotebook } from '../utils/notebookManager.js';
 const { resolve, dirname, isAbsolute } = path;
 const execAsync = promisify(exec);
 /**
@@ -52,8 +56,107 @@ export class FilesystemMCPService {
         });
         this.basePath = resolve(basePath);
     }
+    /**
+     * Extract relevant symbol information for a specific line range
+     * This provides context that helps AI make more accurate modifications
+     * @param symbols - All symbols in the file
+     * @param startLine - Start line of the range
+     * @param endLine - End line of the range
+     * @param _totalLines - Total lines in the file (reserved for future use)
+     * @returns Formatted string with relevant symbol information
+     */
+    extractRelevantSymbols(symbols, startLine, endLine, _totalLines) {
+        if (symbols.length === 0) {
+            return '';
+        }
+        // Categorize symbols
+        const imports = symbols.filter(s => s.type === 'import');
+        const exports = symbols.filter(s => s.type === 'export');
+        // Symbols within the requested range
+        const symbolsInRange = symbols.filter(s => s.line >= startLine && s.line <= endLine);
+        // Symbols defined before the range that might be referenced
+        const symbolsBeforeRange = symbols.filter(s => s.line < startLine);
+        // Build context information
+        const parts = [];
+        // Always include imports (crucial for understanding dependencies)
+        if (imports.length > 0) {
+            const importList = imports
+                .slice(0, 10) // Limit to avoid excessive tokens
+                .map(s => `  • ${s.name} (line ${s.line})`)
+                .join('\n');
+            parts.push(`📦 Imports:\n${importList}`);
+        }
+        // Symbols defined in the current range
+        if (symbolsInRange.length > 0) {
+            const rangeSymbols = symbolsInRange
+                .slice(0, 15)
+                .map(s => `  • ${s.type}: ${s.name} (line ${s.line})${s.signature ? ` - ${s.signature.slice(0, 60)}` : ''}`)
+                .join('\n');
+            parts.push(`🎯 Symbols in this range:\n${rangeSymbols}`);
+        }
+        // Key definitions before this range (that might be referenced)
+        if (symbolsBeforeRange.length > 0 && startLine > 1) {
+            const relevantBefore = symbolsBeforeRange
+                .filter(s => s.type === 'function' || s.type === 'class')
+                .slice(-5) // Last 5 before the range
+                .map(s => `  • ${s.type}: ${s.name} (line ${s.line})`)
+                .join('\n');
+            if (relevantBefore) {
+                parts.push(`⬆️ Key definitions above:\n${relevantBefore}`);
+            }
+        }
+        // Exports (important for understanding module interface)
+        if (exports.length > 0) {
+            const exportList = exports
+                .slice(0, 10)
+                .map(s => `  • ${s.name} (line ${s.line})`)
+                .join('\n');
+            parts.push(`📤 Exports:\n${exportList}`);
+        }
+        if (parts.length === 0) {
+            return '';
+        }
+        return ('\n\n' +
+            '='.repeat(60) +
+            '\n📚 SYMBOL INDEX & DEFINITIONS:\n' +
+            '='.repeat(60) +
+            '\n' +
+            parts.join('\n\n'));
+    }
+    /**
+     * Get notebook entries for a file
+     * @param filePath - Path to the file
+     * @returns Formatted notebook entries string, or empty if none found
+     */
+    getNotebookEntries(filePath) {
+        try {
+            const entries = queryNotebook(filePath, 10);
+            if (entries.length === 0) {
+                return '';
+            }
+            const notesText = entries
+                .map((entry, index) => {
+                // createdAt 已经是本地时间格式: "YYYY-MM-DDTHH:mm:ss.SSS"
+                // 提取日期和时间部分: "YYYY-MM-DD HH:mm"
+                const dateStr = entry.createdAt.substring(0, 16).replace('T', ' ');
+                return `  ${index + 1}. [${dateStr}] ${entry.note}`;
+            })
+                .join('\n');
+            return ('\n\n' +
+                '='.repeat(60) +
+                '\n📝 CODE NOTEBOOKS (Latest 10):\n' +
+                '='.repeat(60) +
+                '\n' +
+                notesText);
+        }
+        catch {
+            // Silently fail notebook retrieval - don't block file reading
+            return '';
+        }
+    }
     /**
      * Get the content of a file with optional line range
+     * Enhanced with symbol information for better AI context
      * @param filePath - Path to the file (relative to base path or absolute) or array of file paths or array of file config objects
      * @param startLine - Starting line number (1-indexed, inclusive, optional - defaults to 1). Used for single file or as default for array of strings
      * @param endLine - Ending line number (1-indexed, inclusive, optional - defaults to file end). Used for single file or as default for array of strings
@@ -127,7 +230,23 @@ export class FilesystemMCPService {
                             const lineNum = start + index;
                             return `${lineNum}→${line}`;
                         });
-                        const fileContent = `📄 ${file} (lines ${start}-${end}/${totalLines})\n${numberedLines.join('\n')}`;
+                        let fileContent = `📄 ${file} (lines ${start}-${end}/${totalLines})\n${numberedLines.join('\n')}`;
+                        // Parse and append symbol information
+                        try {
+                            const symbols = await parseFileSymbols(fullPath, content, this.basePath);
+                            const symbolInfo = this.extractRelevantSymbols(symbols, start, end, totalLines);
+                            if (symbolInfo) {
+                                fileContent += symbolInfo;
+                            }
+                        }
+                        catch {
+                            // Silently fail symbol parsing
+                        }
+                        // Append notebook entries
+                        const notebookInfo = this.getNotebookEntries(file);
+                        if (notebookInfo) {
+                            fileContent += notebookInfo;
+                        }
                         allContents.push(fileContent);
                         filesData.push({
                             path: file,
@@ -197,7 +316,24 @@ export class FilesystemMCPService {
                 const lineNum = start + index;
                 return `${lineNum}→${line}`;
             });
-            const partialContent = numberedLines.join('\n');
+            let partialContent = numberedLines.join('\n');
+            // Parse and append symbol information to provide better context for AI
+            try {
+                const symbols = await parseFileSymbols(fullPath, content, this.basePath);
+                const symbolInfo = this.extractRelevantSymbols(symbols, start, end, totalLines);
+                if (symbolInfo) {
+                    partialContent += symbolInfo;
+                }
+            }
+            catch (error) {
+                // Silently fail symbol parsing - don't block file reading
+                // This is optional context enhancement, not critical
+            }
+            // Append notebook entries
+            const notebookInfo = this.getNotebookEntries(filePath);
+            if (notebookInfo) {
+                partialContent += notebookInfo;
+            }
             return {
                 content: partialContent,
                 startLine: start,

package/dist/mcp/notebook.d.ts

@@ -0,0 +1,10 @@
+import { Tool, type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Notebook MCP 工具定义
+ * 用于代码备忘录管理，帮助AI记录重要的代码注意事项
+ */
+export declare const mcpTools: Tool[];
+/**
+ * 执行 Notebook 工具
+ */
+export declare function executeNotebookTool(toolName: string, args: any): Promise<CallToolResult>;

package/dist/mcp/notebook.js

@@ -0,0 +1,161 @@
+import { addNotebook, queryNotebook } from '../utils/notebookManager.js';
+/**
+ * Notebook MCP 工具定义
+ * 用于代码备忘录管理，帮助AI记录重要的代码注意事项
+ */
+export const mcpTools = [
+    {
+        name: 'notebook-add',
+        description: `📝 Record code parts that are fragile and easily broken during iteration.
+
+**Core Purpose:** Prevent new features from breaking existing functionality.
+
+**When to record:**
+- After fixing bugs that could easily reoccur
+- Fragile code that new features might break
+- Non-obvious dependencies between components
+- Workarounds that shouldn't be "optimized away"
+
+**Examples:**
+- "⚠️ validateInput() MUST be called first - new features broke this twice"
+- "Component X depends on null return - DO NOT change to empty array"
+- "setTimeout workaround for race condition - don't remove"
+- "Parser expects exact format - adding fields breaks backward compat"`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: {
+                    type: 'string',
+                    description: 'File path (relative or absolute). Example: "src/utils/parser.ts"',
+                },
+                note: {
+                    type: 'string',
+                    description: 'Brief, specific note. Focus on risks/constraints, NOT what code does.',
+                },
+            },
+            required: ['filePath', 'note'],
+        },
+    },
+    {
+        name: 'notebook-query',
+        description: `🔍 Search notebook entries by file path pattern.
+
+**Auto-triggered:** When reading files, last 10 notebooks are automatically shown.
+**Manual use:** Query specific patterns or see more entries.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePathPattern: {
+                    type: 'string',
+                    description: 'Fuzzy search pattern (e.g., "parser"). Empty = all entries.',
+                    default: '',
+                },
+                topN: {
+                    type: 'number',
+                    description: 'Max results to return (default: 10, max: 50)',
+                    default: 10,
+                    minimum: 1,
+                    maximum: 50,
+                },
+            },
+        },
+    },
+];
+/**
+ * 执行 Notebook 工具
+ */
+export async function executeNotebookTool(toolName, args) {
+    try {
+        switch (toolName) {
+            case 'notebook-add': {
+                const { filePath, note } = args;
+                if (!filePath || !note) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: Both filePath and note are required',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const entry = addNotebook(filePath, note);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Notebook entry added for: ${entry.filePath}`,
+                                entry: {
+                                    id: entry.id,
+                                    filePath: entry.filePath,
+                                    note: entry.note,
+                                    createdAt: entry.createdAt,
+                                },
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'notebook-query': {
+                const { filePathPattern = '', topN = 10 } = args;
+                const results = queryNotebook(filePathPattern, topN);
+                if (results.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    message: 'No notebook entries found',
+                                    pattern: filePathPattern || '(all)',
+                                    totalResults: 0,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                message: `Found ${results.length} notebook entries`,
+                                pattern: filePathPattern || '(all)',
+                                totalResults: results.length,
+                                entries: results.map(entry => ({
+                                    id: entry.id,
+                                    filePath: entry.filePath,
+                                    note: entry.note,
+                                    createdAt: entry.createdAt,
+                                })),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Unknown notebook tool: ${toolName}`,
+                        },
+                    ],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error executing notebook tool: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}