snow-ai 0.3.30 → 0.3.31

package/dist/api/systemPrompt.js

@@ -176,6 +176,18 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
 - \`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
+- \`notebook-update\` - Update existing note to fix mistakes or refine information
+  - ✏️ Fix errors in previously recorded notes
+  - 📝 Clarify or improve wording after better understanding
+  - 🔄 Update note when code changes but constraint still applies
+- \`notebook-delete\` - Remove outdated or incorrect notes
+  - 🗑️ Delete when code is refactored and note is obsolete
+  - ❌ Remove notes recorded by mistake
+  - 🧹 Clean up after workarounds are properly fixed
+- \`notebook-list\` - View all notes for a specific file
+  - 📋 List all constraints for a file before making changes
+  - 🔍 Find note IDs for update/delete operations
+  - 🧐 Review all warnings before refactoring
 
 **Web Search:**
 - \`websearch-search\` - Search web for latest docs/solutions
@@ -189,13 +201,103 @@ manipulation, workflow automation, and complex command chaining to solve sophist
 system administration and data processing challenges.
 
 **Sub-Agent:** 
-*If you don't have a sub-agent tool, ignore this feature*
-- A sub-agent is a separate session isolated from the main session, and a sub-agent may have some of the tools described above to focus on solving a specific problem.
-If you have a sub-agent tool, then you can leave some of the work to the sub-agent to solve.
-For example, if you have a sub-agent of a work plan, you can hand over the work plan to the sub-agent to solve when you receive user requirements. 
-This way, the master agent can focus on task fulfillment.
 
-- The user may set a sub-agent, and there will be the word \`#agent_*\` in the user's message. \`*\` Is a wildcard,is the tool name of the sub-agent, and you must use this sub-agent.
+### 🎯 CRITICAL: AGGRESSIVE DELEGATION TO SUB-AGENTS
+
+**⚡ Core Principle: MAXIMIZE context saving by delegating as much work as possible to sub-agents!**
+
+**🔥 WHY DELEGATE AGGRESSIVELY:**
+- 💾 **Save Main Context** - Each delegated task saves thousands of tokens in the main session
+- 🚀 **Parallel Processing** - Sub-agents work independently without cluttering main context
+- 🎯 **Focused Sessions** - Sub-agents have dedicated context for specific tasks
+- 🔄 **Scalability** - Main agent stays lean and efficient even for complex projects
+
+**📋 DELEGATION STRATEGY - DEFAULT TO SUB-AGENT:**
+
+**✅ ALWAYS DELEGATE (High Priority):**
+- 🔍 **Code Analysis & Planning** - File structure analysis, architecture review, impact analysis
+- 📊 **Research Tasks** - Investigating patterns, finding similar code, exploring codebase
+- 🗺️ **Work Planning** - Breaking down requirements, creating task plans, designing solutions
+- 📝 **Documentation Review** - Reading and summarizing large files, extracting key information
+- 🔎 **Dependency Mapping** - Finding all imports, exports, references across files
+- 🧪 **Test Planning** - Analyzing what needs testing, planning test cases
+- 🔧 **Refactoring Analysis** - Identifying refactoring opportunities, impact assessment
+
+**✅ STRONGLY CONSIDER DELEGATING:**
+- 🐛 **Bug Investigation** - Root cause analysis, reproduction steps, related code search
+- 🔄 **Migration Planning** - Planning API changes, version upgrades, dependency updates
+- 📐 **Design Reviews** - Evaluating architectural decisions, pattern consistency
+- 🔍 **Code Quality Checks** - Finding code smells, inconsistencies, potential issues
+
+**⚠️ KEEP IN MAIN AGENT (Low Volume):**
+- ✏️ **Direct Code Edits** - Simple, well-understood modifications
+- 🔨 **Quick Fixes** - Single-file changes with clear context
+- ⚡ **Immediate Actions** - Terminal commands, file operations
+
+**🎯 DELEGATION WORKFLOW:**
+
+1. **Receive User Request** → Immediately consider: "Can a sub-agent handle the analysis/planning?"
+2. **Complex Task** → Delegate research/planning to sub-agent, wait for result, then execute
+3. **Multi-Step Task** → Delegate planning to sub-agent, receive roadmap, execute in main
+4. **Unfamiliar Code** → Delegate exploration to sub-agent, get summary, then modify
+
+**💡 PRACTICAL EXAMPLES:**
+
+❌ **BAD - Doing everything in main agent:**
+- User: "Add user authentication"
+- Main: *reads 20 files, analyzes auth patterns, plans implementation, writes code*
+- Result: Main context bloated with analysis that won't be reused
+
+✅ **GOOD - Aggressive delegation:**
+- User: "Add user authentication"
+- Main: Delegate to sub-agent → "Analyze current auth patterns and create implementation plan"
+- Sub-agent: *analyzes, returns concise plan*
+- Main: Execute plan with focused context
+- Result: Main context stays lean, only contains execution context
+
+**🔧 USAGE RULES:**
+
+1. **When tool available**: Check if you have \`subagent-agent_*\` tools in your toolkit
+2. **Explicit user request**: User message contains \`#agent_*\` → MUST use that specific sub-agent
+3. **Implicit delegation**: Even without \`#agent_*\`, proactively delegate analysis/planning tasks
+4. **Return focus**: After sub-agent responds, main agent focuses purely on execution
+
+**📌 REMEMBER: If it's not direct code editing or immediate action, consider delegating to sub-agent first!**
+
+**🌲 DECISION TREE - When to Delegate to Sub-Agent:**
+
+\`\`\`
+📥 User Request
+   ↓
+❓ Can a sub-agent handle this task?
+   ├─ ✅ YES → 🚀 DELEGATE to sub-agent
+   │           ├─ Code search/exploration
+   │           ├─ Analysis & planning
+   │           ├─ Research & investigation
+   │           ├─ Architecture review
+   │           ├─ Impact assessment
+   │           ├─ Dependency mapping
+   │           ├─ Documentation review
+   │           ├─ Test planning
+   │           ├─ Bug investigation
+   │           ├─ Pattern finding
+   │           └─ ANY task sub-agent can do
+   │
+   └─ ❌ NO → Execute directly in main agent
+              ├─ Direct code editing (clear target)
+              ├─ File operations (create/delete)
+              ├─ Simple terminal commands
+              └─ Immediate actions (no research needed)
+\`\`\`
+
+**🎯 Golden Rule:**
+**"If sub-agent CAN do it → sub-agent SHOULD do it"**
+
+**Decision in 3 seconds:**
+1. ❓ Does this need research/exploration/planning? → **Delegate**
+2. ❓ Is this a straightforward code edit? → **Execute directly**
+3. ⚠️ **When in doubt** → **Delegate to sub-agent** (safer default)
+
 
 ## 🔍 Quality Assurance
 

package/dist/hooks/useConversation.js

@@ -692,6 +692,21 @@ export async function handleConversationWithTools(options) {
                 }, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved);
                 // Check if aborted during tool execution
                 if (controller.signal.aborted) {
+                    // Need to add tool results for all pending tool calls to complete conversation history
+                    // This is critical for sub-agents and any tools that were being executed
+                    if (receivedToolCalls && receivedToolCalls.length > 0) {
+                        for (const toolCall of receivedToolCalls) {
+                            const abortedResult = {
+                                role: 'tool',
+                                tool_call_id: toolCall.id,
+                                content: 'Error: Tool execution aborted by user',
+                            };
+                            conversationMessages.push(abortedResult);
+                            saveMessage(abortedResult).catch(error => {
+                                console.error('Failed to save aborted tool result:', error);
+                            });
+                        }
+                    }
                     freeEncoder();
                     break;
                 }

package/dist/mcp/notebook.js

@@ -1,4 +1,4 @@
-import { addNotebook, queryNotebook } from '../utils/notebookManager.js';
+import { addNotebook, queryNotebook, updateNotebook, deleteNotebook, getNotebooksByFile, } from '../utils/notebookManager.js';
 /**
  * Notebook MCP 工具定义
  * 用于代码备忘录管理，帮助AI记录重要的代码注意事项
@@ -60,6 +60,91 @@ export const mcpTools = [
             },
         },
     },
+    {
+        name: 'notebook-update',
+        description: `✏️ Update an existing notebook entry to fix mistakes or refine notes.
+
+**Core Purpose:** Correct errors in previously recorded notes or update outdated information.
+
+**When to use:**
+- Found a mistake in a previously recorded note
+- Need to clarify or improve the wording
+- Update note after code changes
+- Refine warning messages for better clarity
+
+**Usage:**
+1. Use notebook-query or notebook-list to find the entry ID
+2. Call notebook-update with the ID and new note content
+
+**Example:**
+- Old: "⚠️ Don't change this"
+- New: "⚠️ validateInput() MUST be called first - parser depends on sanitized input"`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                notebookId: {
+                    type: 'string',
+                    description: 'Notebook entry ID to update (get from notebook-query or notebook-list)',
+                },
+                note: {
+                    type: 'string',
+                    description: 'New note content to replace the existing one',
+                },
+            },
+            required: ['notebookId', 'note'],
+        },
+    },
+    {
+        name: 'notebook-delete',
+        description: `🗑️ Delete an outdated or incorrect notebook entry.
+
+**Core Purpose:** Remove notes that are no longer relevant or were recorded by mistake.
+
+**When to use:**
+- Code has been refactored and note is obsolete
+- Note was recorded by mistake
+- Workaround has been properly fixed
+- Entry is duplicate or redundant
+
+**Usage:**
+1. Use notebook-query or notebook-list to find the entry ID
+2. Call notebook-delete with the ID to remove it
+
+**⚠️ Warning:** Deletion is permanent. Make sure the note is truly obsolete.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                notebookId: {
+                    type: 'string',
+                    description: 'Notebook entry ID to delete (get from notebook-query)',
+                },
+            },
+            required: ['notebookId'],
+        },
+    },
+    {
+        name: 'notebook-list',
+        description: `📋 List all notebook entries for a specific file.
+
+**Core Purpose:** View all notes associated with a particular file for management.
+
+**When to use:**
+- Need to see all notes for a file before editing
+- Want to clean up old notes for a specific file
+- Review constraints before making changes to a file
+
+**Returns:** All notebook entries for the specified file, ordered by creation time.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: {
+                    type: 'string',
+                    description: 'File path (relative or absolute) to list notebooks for',
+                },
+            },
+            required: ['filePath'],
+        },
+    },
 ];
 /**
  * 执行 Notebook 工具
@@ -135,6 +220,127 @@ export async function executeNotebookTool(toolName, args) {
                     ],
                 };
             }
+            case 'notebook-update': {
+                const { notebookId, note } = args;
+                if (!notebookId || !note) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: Both notebookId and note are required',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const updatedEntry = updateNotebook(notebookId, note);
+                if (!updatedEntry) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    message: `Notebook entry not found: ${notebookId}`,
+                                }, null, 2),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Notebook entry updated: ${notebookId}`,
+                                entry: {
+                                    id: updatedEntry.id,
+                                    filePath: updatedEntry.filePath,
+                                    note: updatedEntry.note,
+                                    updatedAt: updatedEntry.updatedAt,
+                                },
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'notebook-delete': {
+                const { notebookId } = args;
+                if (!notebookId) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: notebookId is required',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const deleted = deleteNotebook(notebookId);
+                if (!deleted) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    message: `Notebook entry not found: ${notebookId}`,
+                                }, null, 2),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Notebook entry deleted: ${notebookId}`,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'notebook-list': {
+                const { filePath } = args;
+                if (!filePath) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: filePath is required',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const entries = getNotebooksByFile(filePath);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                message: entries.length > 0
+                                    ? `Found ${entries.length} notebook entries for: ${filePath}`
+                                    : `No notebook entries found for: ${filePath}`,
+                                filePath,
+                                totalEntries: entries.length,
+                                entries: entries.map(entry => ({
+                                    id: entry.id,
+                                    note: entry.note,
+                                    createdAt: entry.createdAt,
+                                    updatedAt: entry.updatedAt,
+                                })),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
             default:
                 return {
                     content: [

package/dist/utils/notebookManager.d.ts

@@ -28,6 +28,13 @@ export declare function queryNotebook(filePathPattern?: string, topN?: number):
  * @returns 该文件的所有备忘录
  */
 export declare function getNotebooksByFile(filePath: string): NotebookEntry[];
+/**
+ * 更新备忘录内容
+ * @param notebookId 备忘录ID
+ * @param newNote 新的备忘说明
+ * @returns 更新后的备忘录条目，如果未找到则返回null
+ */
+export declare function updateNotebook(notebookId: string, newNote: string): NotebookEntry | null;
 /**
  * 删除备忘录
  * @param notebookId 备忘录ID

package/dist/utils/notebookManager.js

@@ -130,6 +130,31 @@ export function getNotebooksByFile(filePath) {
     const data = readNotebookData();
     return data[normalizedPath] || [];
 }
+/**
+ * 更新备忘录内容
+ * @param notebookId 备忘录ID
+ * @param newNote 新的备忘说明
+ * @returns 更新后的备忘录条目，如果未找到则返回null
+ */
+export function updateNotebook(notebookId, newNote) {
+    const data = readNotebookData();
+    let updatedEntry = null;
+    for (const [, entries] of Object.entries(data)) {
+        const entry = entries.find(e => e.id === notebookId);
+        if (entry) {
+            // 更新笔记内容和更新时间
+            entry.note = newNote;
+            const now = new Date();
+            entry.updatedAt = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}T${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}.${String(now.getMilliseconds()).padStart(3, '0')}`;
+            updatedEntry = entry;
+            break;
+        }
+    }
+    if (updatedEntry) {
+        saveNotebookData(data);
+    }
+    return updatedEntry;
+}
 /**
  * 删除备忘录
  * @param notebookId 备忘录ID

package/dist/utils/subAgentExecutor.js

@@ -70,8 +70,19 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
         const sessionApprovedTools = new Set();
         // eslint-disable-next-line no-constant-condition
         while (true) {
-            // Check abort signal
+            // Check abort signal before streaming
             if (abortSignal?.aborted) {
+                // Send done message to mark completion (like normal tool abort)
+                if (onMessage) {
+                    onMessage({
+                        type: 'sub_agent_message',
+                        agentId: agent.id,
+                        agentName: agent.name,
+                        message: {
+                            type: 'done',
+                        },
+                    });
+                }
                 return {
                     success: false,
                     result: finalResponse,
@@ -200,6 +211,17 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
             }
             // Handle rejected tools
             if (rejectedToolCalls.length > 0) {
+                // Send done message to mark completion when tools are rejected
+                if (onMessage) {
+                    onMessage({
+                        type: 'sub_agent_message',
+                        agentId: agent.id,
+                        agentName: agent.name,
+                        message: {
+                            type: 'done',
+                        },
+                    });
+                }
                 return {
                     success: false,
                     result: finalResponse,
@@ -211,6 +233,25 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
             // Execute approved tool calls
             const toolResults = [];
             for (const toolCall of approvedToolCalls) {
+                // Check abort signal before executing each tool
+                if (abortSignal?.aborted) {
+                    // Send done message to mark completion
+                    if (onMessage) {
+                        onMessage({
+                            type: 'sub_agent_message',
+                            agentId: agent.id,
+                            agentName: agent.name,
+                            message: {
+                                type: 'done',
+                            },
+                        });
+                    }
+                    return {
+                        success: false,
+                        result: finalResponse,
+                        error: 'Sub-agent execution aborted during tool execution',
+                    };
+                }
                 try {
                     const args = JSON.parse(toolCall.function.arguments);
                     const result = await executeMCPTool(toolCall.function.name, args, abortSignal);

package/package.json

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