snow-ai 0.3.36 → 0.4.0

package/dist/utils/configManager.js

@@ -4,7 +4,8 @@ import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlink
 import { loadConfig, saveConfig } from './apiConfig.js';
 const CONFIG_DIR = join(homedir(), '.snow');
 const PROFILES_DIR = join(CONFIG_DIR, 'profiles');
-const ACTIVE_PROFILE_FILE = join(CONFIG_DIR, 'active-profile.txt');
+const ACTIVE_PROFILE_FILE = join(CONFIG_DIR, 'active-profile.json');
+const LEGACY_ACTIVE_PROFILE_FILE = join(CONFIG_DIR, 'active-profile.txt');
 const LEGACY_CONFIG_FILE = join(CONFIG_DIR, 'config.json');
 /**
  * Ensure the profiles directory exists
@@ -22,12 +23,29 @@ function ensureProfilesDirectory() {
  */
 export function getActiveProfileName() {
     ensureProfilesDirectory();
+    // Auto-migrate from legacy .txt format to new .json format
+    if (!existsSync(ACTIVE_PROFILE_FILE) &&
+        existsSync(LEGACY_ACTIVE_PROFILE_FILE)) {
+        try {
+            const legacyProfileName = readFileSync(LEGACY_ACTIVE_PROFILE_FILE, 'utf8').trim();
+            const profileName = legacyProfileName || 'default';
+            // Save in new JSON format
+            setActiveProfileName(profileName);
+            // Delete old .txt file
+            unlinkSync(LEGACY_ACTIVE_PROFILE_FILE);
+            return profileName;
+        }
+        catch {
+            // If migration fails, continue with default
+        }
+    }
     if (!existsSync(ACTIVE_PROFILE_FILE)) {
         return 'default';
     }
     try {
-        const profileName = readFileSync(ACTIVE_PROFILE_FILE, 'utf8').trim();
-        return profileName || 'default';
+        const fileContent = readFileSync(ACTIVE_PROFILE_FILE, 'utf8').trim();
+        const data = JSON.parse(fileContent);
+        return data.activeProfile || 'default';
     }
     catch {
         return 'default';
@@ -39,7 +57,8 @@ export function getActiveProfileName() {
 function setActiveProfileName(profileName) {
     ensureProfilesDirectory();
     try {
-        writeFileSync(ACTIVE_PROFILE_FILE, profileName, 'utf8');
+        const data = { activeProfile: profileName };
+        writeFileSync(ACTIVE_PROFILE_FILE, JSON.stringify(data, null, 2), 'utf8');
     }
     catch (error) {
         throw new Error(`Failed to set active profile: ${error}`);
@@ -180,7 +199,9 @@ export function switchProfile(profileName) {
 export function createProfile(profileName, config) {
     ensureProfilesDirectory();
     // Validate profile name
-    if (!profileName.trim() || profileName.includes('/') || profileName.includes('\\')) {
+    if (!profileName.trim() ||
+        profileName.includes('/') ||
+        profileName.includes('\\')) {
         throw new Error('Invalid profile name');
     }
     const profilePath = getProfilePath(profileName);

package/dist/utils/contextCompressor.js

@@ -104,7 +104,7 @@ function prepareMessagesForCompression(conversationMessages, customSystemPrompt)
     if (customSystemPrompt) {
         // If custom system prompt exists: custom as system, default as first user message
         messages.push({ role: 'system', content: customSystemPrompt });
-        messages.push({ role: 'user', content: getSystemPrompt() });
+        // messages.push({role: 'user', content: getSystemPrompt()});
     }
     else {
         // No custom system prompt: default as system

package/dist/utils/languageConfig.d.ts

@@ -0,0 +1,21 @@
+export type Language = 'en' | 'zh' | 'zh-TW' | 'ja' | 'ko' | 'es';
+interface LanguageConfig {
+    language: Language;
+}
+/**
+ * Load language configuration from file system
+ */
+export declare function loadLanguageConfig(): LanguageConfig;
+/**
+ * Save language configuration to file system
+ */
+export declare function saveLanguageConfig(config: LanguageConfig): void;
+/**
+ * Get current language setting
+ */
+export declare function getCurrentLanguage(): Language;
+/**
+ * Set language and persist to file system
+ */
+export declare function setCurrentLanguage(language: Language): void;
+export {};

package/dist/utils/languageConfig.js

@@ -0,0 +1,61 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+const CONFIG_DIR = join(homedir(), '.snow');
+const LANGUAGE_CONFIG_FILE = join(CONFIG_DIR, 'language.json');
+const DEFAULT_CONFIG = {
+    language: 'en',
+};
+function ensureConfigDirectory() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+/**
+ * Load language configuration from file system
+ */
+export function loadLanguageConfig() {
+    ensureConfigDirectory();
+    if (!existsSync(LANGUAGE_CONFIG_FILE)) {
+        saveLanguageConfig(DEFAULT_CONFIG);
+        return DEFAULT_CONFIG;
+    }
+    try {
+        const configData = readFileSync(LANGUAGE_CONFIG_FILE, 'utf-8');
+        const config = JSON.parse(configData);
+        return {
+            ...DEFAULT_CONFIG,
+            ...config,
+        };
+    }
+    catch (error) {
+        // If config file is corrupted, return default config
+        return DEFAULT_CONFIG;
+    }
+}
+/**
+ * Save language configuration to file system
+ */
+export function saveLanguageConfig(config) {
+    ensureConfigDirectory();
+    try {
+        const configData = JSON.stringify(config, null, 2);
+        writeFileSync(LANGUAGE_CONFIG_FILE, configData, 'utf-8');
+    }
+    catch (error) {
+        console.error('Failed to save language config:', error);
+    }
+}
+/**
+ * Get current language setting
+ */
+export function getCurrentLanguage() {
+    const config = loadLanguageConfig();
+    return config.language;
+}
+/**
+ * Set language and persist to file system
+ */
+export function setCurrentLanguage(language) {
+    saveLanguageConfig({ language });
+}

package/dist/utils/mcpToolsManager.js

@@ -703,15 +703,6 @@ export async function executeMCPTool(toolName, args, abortSignal, onTokenUpdate)
                 return await filesystemService.getFileContent(args.filePath, args.startLine, args.endLine);
             case 'create':
                 return await filesystemService.createFile(args.filePath, args.content, args.createDirectories);
-            case 'delete':
-                // Support both filePath (legacy) and filePaths (new) parameters
-                const pathsToDelete = args.filePaths || args.filePath;
-                if (!pathsToDelete) {
-                    throw new Error('Missing required parameter: filePath or filePaths');
-                }
-                return await filesystemService.deleteFile(pathsToDelete);
-            case 'list':
-                return await filesystemService.listFiles(args.dirPath);
             case 'exists':
                 return await filesystemService.exists(args.filePath);
             case 'info':

package/dist/utils/notebookManager.js

@@ -60,8 +60,13 @@ function normalizePath(filePath) {
     if (path.isAbsolute(filePath)) {
         return path.relative(projectRoot, filePath).replace(/\\/g, '/');
     }
-    // 已经是相对路径，规范化斜杠
-    return filePath.replace(/\\/g, '/');
+    // 已经是相对路径，规范化斜杠并移除 ./ 前缀
+    let normalized = filePath.replace(/\\/g, '/');
+    // 移除开头的 ./ 前缀
+    if (normalized.startsWith('./')) {
+        normalized = normalized.substring(2);
+    }
+    return normalized;
 }
 /**
  * 添加备忘录
@@ -103,8 +108,10 @@ export function addNotebook(filePath, note) {
 export function queryNotebook(filePathPattern = '', topN = 10) {
     const data = readNotebookData();
     const results = [];
-    // 规范化搜索模式
-    const normalizedPattern = filePathPattern.toLowerCase().replace(/\\/g, '/');
+    // 规范化搜索模式（移除 ./ 前缀等）
+    const normalizedPattern = filePathPattern
+        ? normalizePath(filePathPattern).toLowerCase()
+        : '';
     // 遍历所有文件路径
     for (const [filePath, entries] of Object.entries(data)) {
         // 如果没有指定模式，或者文件路径包含模式

package/dist/utils/sessionConverter.js

@@ -36,7 +36,7 @@ export function convertSessionMessagesToUI(sessionMessages) {
                             name: toolCall.function.name,
                             arguments: toolArgs,
                         },
-                        toolDisplay,
+                        // Don't include toolDisplay for sub-agent tools to avoid showing parameters
                         toolCallId: toolCall.id,
                         toolPending: false,
                         subAgentInternal: true,
@@ -154,8 +154,18 @@ export function convertSessionMessagesToUI(sessionMessages) {
         // Handle regular tool result messages (non-subagent)
         if (msg.role === 'tool' && msg.tool_call_id && !msg.subAgentInternal) {
             const isError = msg.content.startsWith('Error:');
-            const statusIcon = isError ? '✗' : '✓';
-            const statusText = isError ? `\n  └─ ${msg.content}` : '';
+            const isRejectedWithReply = msg.content.includes('Tool execution rejected by user:');
+            const statusIcon = isError || isRejectedWithReply ? '✗' : '✓';
+            let statusText = '';
+            if (isError) {
+                statusText = `\n  └─ ${msg.content}`;
+            }
+            else if (isRejectedWithReply) {
+                // Extract rejection reason
+                const reason = msg.content.split('Tool execution rejected by user:')[1]?.trim() ||
+                    '';
+                statusText = reason ? `\n  └─ Rejection reason: ${reason}` : '';
+            }
             // Find tool name and args from previous assistant message
             let toolName = 'tool';
             let toolArgs = {};

package/dist/utils/sessionManager.d.ts

@@ -1,6 +1,7 @@
 import type { ChatMessage as APIChatMessage } from '../api/chat.js';
 export interface ChatMessage extends APIChatMessage {
     timestamp: number;
+    originalContent?: string;
 }
 export interface Session {
     id: string;

package/dist/utils/subAgentConfig.d.ts

@@ -6,24 +6,29 @@ export interface SubAgent {
     tools: string[];
     createdAt: string;
     updatedAt: string;
+    builtin?: boolean;
 }
 export interface SubAgentsConfig {
     agents: SubAgent[];
 }
 /**
- * Get all sub-agents
+ * Get user-configured sub-agents only (exported for MCP tool generation)
+ */
+export declare function getUserSubAgents(): SubAgent[];
+/**
+ * Get all sub-agents (built-in + user-configured)
  */
 export declare function getSubAgents(): SubAgent[];
 /**
- * Get a sub-agent by ID
+ * Get a sub-agent by ID (checks both built-in and user-configured)
  */
 export declare function getSubAgent(id: string): SubAgent | null;
 /**
- * Create a new sub-agent
+ * Create a new sub-agent (user-configured only)
  */
 export declare function createSubAgent(name: string, description: string, tools: string[], role?: string): SubAgent;
 /**
- * Update an existing sub-agent
+ * Update an existing sub-agent (only user-configured agents can be updated)
  */
 export declare function updateSubAgent(id: string, updates: {
     name?: string;
@@ -32,7 +37,7 @@ export declare function updateSubAgent(id: string, updates: {
     tools?: string[];
 }): SubAgent | null;
 /**
- * Delete a sub-agent
+ * Delete a sub-agent (only user-configured agents can be deleted)
  */
 export declare function deleteSubAgent(id: string): boolean;
 /**

package/dist/utils/subAgentConfig.js

@@ -3,6 +3,77 @@ import { join } from 'path';
 import { homedir } from 'os';
 const CONFIG_DIR = join(homedir(), '.snow');
 const SUB_AGENTS_CONFIG_FILE = join(CONFIG_DIR, 'sub-agents.json');
+/**
+ * Built-in sub-agents (hardcoded, always available)
+ */
+const BUILTIN_AGENTS = [
+    {
+        id: 'agent_explore',
+        name: 'Explore Agent',
+        description: 'Specialized for quickly exploring and understanding codebases. Excels at searching code, finding definitions, analyzing code structure and dependencies. Read-only operations.',
+        role: 'You are a specialized code exploration agent. Your task is to help users understand codebase structure, locate specific code, and analyze dependencies. Use search and analysis tools to explore code, but do not modify any files or execute commands. Focus on code discovery and understanding.',
+        tools: [
+            'filesystem-read',
+            'ace-find_definition',
+            'ace-find_references',
+            'ace-semantic_search',
+            'ace-text_search',
+            'ace-file_outline',
+            'codebase-search',
+            'websearch-search',
+            'websearch-fetch',
+        ],
+        createdAt: '2024-01-01T00:00:00.000Z',
+        updatedAt: '2024-01-01T00:00:00.000Z',
+        builtin: true,
+    },
+    {
+        id: 'agent_plan',
+        name: 'Plan Agent',
+        description: 'Specialized for planning complex tasks. Analyzes requirements, explores code, identifies relevant files, and creates detailed implementation plans. Read-only operations.',
+        role: 'You are a specialized task planning agent. Your task is to analyze user requirements, explore existing codebase, identify relevant files and dependencies, and then create detailed implementation plans. Use search and analysis tools to gather information, check diagnostics to understand current state, but do not execute actual modifications. Output clear step-by-step plans including files to modify, suggested implementation approaches, and important considerations.',
+        tools: [
+            'filesystem-read',
+            'ace-find_definition',
+            'ace-find_references',
+            'ace-semantic_search',
+            'ace-text_search',
+            'ace-file_outline',
+            'ide-get_diagnostics',
+            'codebase-search',
+            'websearch-search',
+            'websearch-fetch',
+        ],
+        createdAt: '2024-01-01T00:00:00.000Z',
+        updatedAt: '2024-01-01T00:00:00.000Z',
+        builtin: true,
+    },
+    {
+        id: 'agent_general',
+        name: 'General Purpose Agent',
+        description: 'General-purpose multi-step task execution agent. Has complete tool access for searching, modifying files, and executing commands. Best for complex tasks requiring actual operations.',
+        role: 'You are a general-purpose task execution agent. You can perform various complex multi-step tasks, including searching code, modifying files, executing commands, etc. When given a task, systematically break it down and execute. You have access to all tools and should select appropriate tools as needed to complete tasks efficiently.',
+        tools: [
+            'filesystem-read',
+            'filesystem-create',
+            'filesystem-edit',
+            'filesystem-edit_search',
+            'terminal-execute',
+            'ace-find_definition',
+            'ace-find_references',
+            'ace-semantic_search',
+            'ace-text_search',
+            'ace-file_outline',
+            'websearch-search',
+            'websearch-fetch',
+            'ide-get_diagnostics',
+            'codebase-search',
+        ],
+        createdAt: '2024-01-01T00:00:00.000Z',
+        updatedAt: '2024-01-01T00:00:00.000Z',
+        builtin: true,
+    },
+];
 function ensureConfigDirectory() {
     if (!existsSync(CONFIG_DIR)) {
         mkdirSync(CONFIG_DIR, { recursive: true });
@@ -12,9 +83,9 @@ function generateId() {
     return `agent_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
 }
 /**
- * Get all sub-agents
+ * Get user-configured sub-agents only (exported for MCP tool generation)
  */
-export function getSubAgents() {
+export function getUserSubAgents() {
     try {
         ensureConfigDirectory();
         if (!existsSync(SUB_AGENTS_CONFIG_FILE)) {
@@ -30,19 +101,29 @@ export function getSubAgents() {
     }
 }
 /**
- * Get a sub-agent by ID
+ * Get all sub-agents (built-in + user-configured)
+ */
+export function getSubAgents() {
+    const userAgents = getUserSubAgents();
+    // Return built-in agents first, then user-configured agents
+    return [...BUILTIN_AGENTS, ...userAgents];
+}
+/**
+ * Get a sub-agent by ID (checks both built-in and user-configured)
  */
 export function getSubAgent(id) {
     const agents = getSubAgents();
     return agents.find(agent => agent.id === id) || null;
 }
 /**
- * Save all sub-agents
+ * Save user-configured sub-agents only (never saves built-in agents)
  */
 function saveSubAgents(agents) {
     try {
         ensureConfigDirectory();
-        const config = { agents };
+        // Filter out built-in agents (should never be saved to config)
+        const userAgents = agents.filter(agent => !agent.builtin);
+        const config = { agents: userAgents };
         const configData = JSON.stringify(config, null, 2);
         writeFileSync(SUB_AGENTS_CONFIG_FILE, configData, 'utf8');
     }
@@ -51,10 +132,10 @@ function saveSubAgents(agents) {
     }
 }
 /**
- * Create a new sub-agent
+ * Create a new sub-agent (user-configured only)
  */
 export function createSubAgent(name, description, tools, role) {
-    const agents = getSubAgents();
+    const userAgents = getUserSubAgents();
     const now = new Date().toISOString();
     const newAgent = {
         id: generateId(),
@@ -64,21 +145,27 @@ export function createSubAgent(name, description, tools, role) {
         tools,
         createdAt: now,
         updatedAt: now,
+        builtin: false,
     };
-    agents.push(newAgent);
-    saveSubAgents(agents);
+    userAgents.push(newAgent);
+    saveSubAgents(userAgents);
     return newAgent;
 }
 /**
- * Update an existing sub-agent
+ * Update an existing sub-agent (only user-configured agents can be updated)
  */
 export function updateSubAgent(id, updates) {
-    const agents = getSubAgents();
-    const index = agents.findIndex(agent => agent.id === id);
+    // Prevent updating built-in agents
+    const agent = getSubAgent(id);
+    if (agent?.builtin) {
+        throw new Error('Cannot update built-in agents');
+    }
+    const userAgents = getUserSubAgents();
+    const index = userAgents.findIndex(agent => agent.id === id);
     if (index === -1) {
         return null;
     }
-    const existingAgent = agents[index];
+    const existingAgent = userAgents[index];
     if (!existingAgent) {
         return null;
     }
@@ -90,18 +177,24 @@ export function updateSubAgent(id, updates) {
         tools: updates.tools ?? existingAgent.tools,
         createdAt: existingAgent.createdAt,
         updatedAt: new Date().toISOString(),
+        builtin: false,
     };
-    agents[index] = updatedAgent;
-    saveSubAgents(agents);
+    userAgents[index] = updatedAgent;
+    saveSubAgents(userAgents);
     return updatedAgent;
 }
 /**
- * Delete a sub-agent
+ * Delete a sub-agent (only user-configured agents can be deleted)
  */
 export function deleteSubAgent(id) {
-    const agents = getSubAgents();
-    const filteredAgents = agents.filter(agent => agent.id !== id);
-    if (filteredAgents.length === agents.length) {
+    // Prevent deleting built-in agents
+    const agent = getSubAgent(id);
+    if (agent?.builtin) {
+        throw new Error('Cannot delete built-in agents');
+    }
+    const userAgents = getUserSubAgents();
+    const filteredAgents = userAgents.filter(agent => agent.id !== id);
+    if (filteredAgents.length === userAgents.length) {
         return false; // Agent not found
     }
     saveSubAgents(filteredAgents);

package/dist/utils/subAgentExecutor.d.ts

@@ -1,16 +1,24 @@
+import type { ConfirmationResult } from '../ui/components/ToolConfirmation.js';
 export interface SubAgentMessage {
     type: 'sub_agent_message';
     agentId: string;
     agentName: string;
     message: any;
 }
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationInputTokens?: number;
+    cacheReadInputTokens?: number;
+}
 export interface SubAgentResult {
     success: boolean;
     result: string;
     error?: string;
+    usage?: TokenUsage;
 }
 export interface ToolConfirmationCallback {
-    (toolName: string, toolArgs: any): Promise<string>;
+    (toolName: string, toolArgs: any): Promise<ConfirmationResult>;
 }
 export interface ToolApprovalChecker {
     (toolName: string): boolean;