snow-ai 0.1.12 → 0.2.2

package/dist/ui/pages/MCPConfigScreen.d.ts

@@ -0,0 +1,6 @@
+type Props = {
+    onBack: () => void;
+    onSave: () => void;
+};
+export default function MCPConfigScreen({ onBack }: Props): null;
+export {};

package/dist/ui/pages/MCPConfigScreen.js

@@ -0,0 +1,55 @@
+import { useEffect } from 'react';
+import { useApp } from 'ink';
+import { spawn } from 'child_process';
+import { writeFileSync, readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir, platform } from 'os';
+import { getMCPConfig, validateMCPConfig, } from '../../utils/apiConfig.js';
+const CONFIG_DIR = join(homedir(), '.snow');
+const MCP_CONFIG_FILE = join(CONFIG_DIR, 'mcp-config.json');
+function getSystemEditor() {
+    if (platform() === 'win32') {
+        return 'notepad';
+    }
+    return process.env['EDITOR'] || 'vim';
+}
+export default function MCPConfigScreen({ onBack }) {
+    const { exit } = useApp();
+    useEffect(() => {
+        const openEditor = async () => {
+            const config = getMCPConfig();
+            writeFileSync(MCP_CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+            const editor = getSystemEditor();
+            exit();
+            const child = spawn(editor, [MCP_CONFIG_FILE], {
+                stdio: 'inherit'
+            });
+            child.on('close', () => {
+                // 读取编辑后的配置
+                if (existsSync(MCP_CONFIG_FILE)) {
+                    try {
+                        const editedContent = readFileSync(MCP_CONFIG_FILE, 'utf8');
+                        const parsedConfig = JSON.parse(editedContent);
+                        const validationErrors = validateMCPConfig(parsedConfig);
+                        if (validationErrors.length === 0) {
+                            console.log('MCP configuration saved successfully ! Please use `snow` restart!');
+                        }
+                        else {
+                            console.error('Configuration errors:', validationErrors.join(', '));
+                        }
+                    }
+                    catch (parseError) {
+                        console.error('Invalid JSON format');
+                    }
+                }
+                process.exit(0);
+            });
+            child.on('error', (error) => {
+                console.error('Failed to open editor:', error.message);
+                process.exit(1);
+            });
+        };
+        openEditor();
+    }, [exit, onBack]);
+    return null;
+}

package/dist/ui/pages/ModelConfigScreen.js

@@ -12,9 +12,10 @@ export default function ModelConfigScreen({ onBack, onSave }) {
     const [isEditing, setIsEditing] = useState(false);
     const [models, setModels] = useState([]);
     const [loading, setLoading] = useState(false);
-    const [error, setError] = useState('');
     const [baseUrlMissing, setBaseUrlMissing] = useState(false);
     const [searchTerm, setSearchTerm] = useState('');
+    const [manualInputMode, setManualInputMode] = useState(false);
+    const [manualInputValue, setManualInputValue] = useState('');
     useEffect(() => {
         const config = getOpenAiConfig();
         setAdvancedModel(config.advancedModel || '');
@@ -27,13 +28,13 @@ export default function ModelConfigScreen({ onBack, onSave }) {
     }, []);
     const loadModels = async () => {
         setLoading(true);
-        setError('');
         try {
             const fetchedModels = await fetchAvailableModels();
             setModels(fetchedModels);
         }
         catch (err) {
-            setError(err instanceof Error ? err.message : 'Failed to load models');
+            // 加载失败时抛出错误,由调用方处理
+            throw err;
         }
         finally {
             setLoading(false);
@@ -41,10 +42,15 @@ export default function ModelConfigScreen({ onBack, onSave }) {
     };
     const getCurrentOptions = () => {
         const filteredModels = filterModels(models, searchTerm);
-        return filteredModels.map(model => ({
+        const modelOptions = filteredModels.map(model => ({
             label: model.id,
             value: model.id,
         }));
+        // 添加手动输入选项
+        return [
+            { label: 'Manual Input (Enter model name)', value: '__MANUAL_INPUT__' },
+            ...modelOptions,
+        ];
     };
     const getCurrentValue = () => {
         if (currentField === 'advancedModel')
@@ -54,6 +60,12 @@ export default function ModelConfigScreen({ onBack, onSave }) {
         return maxContextTokens.toString();
     };
     const handleModelChange = (value) => {
+        // 如果选择了手动输入选项
+        if (value === '__MANUAL_INPUT__') {
+            setManualInputMode(true);
+            setManualInputValue('');
+            return;
+        }
         if (currentField === 'advancedModel') {
             setAdvancedModel(value);
         }
@@ -76,6 +88,36 @@ export default function ModelConfigScreen({ onBack, onSave }) {
             }
             return;
         }
+        // 处理手动输入模式
+        if (manualInputMode) {
+            if (key.return) {
+                // 确认输入
+                if (manualInputValue.trim()) {
+                    if (currentField === 'advancedModel') {
+                        setAdvancedModel(manualInputValue.trim());
+                    }
+                    else if (currentField === 'basicModel') {
+                        setBasicModel(manualInputValue.trim());
+                    }
+                }
+                setManualInputMode(false);
+                setManualInputValue('');
+                setIsEditing(false);
+                setSearchTerm('');
+            }
+            else if (key.escape) {
+                // 取消输入
+                setManualInputMode(false);
+                setManualInputValue('');
+            }
+            else if (key.backspace || key.delete) {
+                setManualInputValue(prev => prev.slice(0, -1));
+            }
+            else if (input && input.match(/[a-zA-Z0-9-_./:]/)) {
+                setManualInputValue(prev => prev + input);
+            }
+            return;
+        }
         // Don't handle input when Select component is active
         if (isEditing) {
             if (currentField === 'maxContextTokens') {
@@ -143,9 +185,20 @@ export default function ModelConfigScreen({ onBack, onSave }) {
             else {
                 loadModels().then(() => {
                     setIsEditing(true);
+                }).catch(() => {
+                    // 如果加载模型失败，直接进入手动输入模式
+                    setManualInputMode(true);
+                    setManualInputValue(getCurrentValue());
                 });
             }
         }
+        else if (input === 'm') {
+            // 快捷键：按 'm' 直接进入手动输入模式
+            if (currentField !== 'maxContextTokens') {
+                setManualInputMode(true);
+                setManualInputValue(getCurrentValue());
+            }
+        }
         else if (key.upArrow) {
             if (currentField === 'basicModel') {
                 setCurrentField('advancedModel');
@@ -181,16 +234,24 @@ export default function ModelConfigScreen({ onBack, onSave }) {
                     React.createElement(Gradient, { name: "rainbow" }, "Model Configuration"),
                     React.createElement(Text, { color: "gray", dimColor: true }, "Loading available models...")))));
     }
-    if (error) {
+    // 手动输入模式的界面
+    if (manualInputMode) {
         return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-            React.createElement(Box, { marginBottom: 2, borderStyle: "double", borderColor: "red", paddingX: 2, paddingY: 1 },
+            React.createElement(Box, { marginBottom: 2, borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1 },
                 React.createElement(Box, { flexDirection: "column" },
-                    React.createElement(Gradient, { name: 'rainbow' }, "Model Configuration"),
-                    React.createElement(Text, { color: "gray", dimColor: true }, "Configure AI models for different tasks"))),
-            React.createElement(Box, { marginBottom: 2 },
-                React.createElement(Alert, { variant: "error" }, error)),
+                    React.createElement(Gradient, { name: 'rainbow' }, "Manual Input Model"),
+                    React.createElement(Text, { color: "gray", dimColor: true }, "Enter model name manually"))),
+            React.createElement(Box, { flexDirection: "column", marginBottom: 2 },
+                React.createElement(Text, { color: "cyan" },
+                    currentField === 'advancedModel' ? 'Advanced Model' : 'Basic Model',
+                    ":"),
+                React.createElement(Box, { marginLeft: 2, marginTop: 1 },
+                    React.createElement(Text, { color: "green" },
+                        `> ${manualInputValue}`,
+                        React.createElement(Text, { color: "white" }, "_")))),
             React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Alert, { variant: "info" }, "Press Esc to return to main menu"))));
+                React.createElement(Alert, { variant: "info" }, "Type model name (e.g., gpt-4o, claude-3-5-sonnet-20241022)"),
+                React.createElement(Alert, { variant: "info" }, "Press Enter to confirm, Esc to cancel"))));
     }
     return (React.createElement(Box, { flexDirection: "column", padding: 1 },
         React.createElement(Box, { marginBottom: 2, borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1 },
@@ -235,5 +296,5 @@ export default function ModelConfigScreen({ onBack, onSave }) {
                         React.createElement(Text, { color: "gray" }, maxContextTokens)))))),
         React.createElement(Box, { flexDirection: "column" }, isEditing ? (React.createElement(React.Fragment, null,
             React.createElement(Alert, { variant: "info" }, "Editing mode: Type to filter models, \u2191\u2193 to select, Enter to confirm"))) : (React.createElement(React.Fragment, null,
-            React.createElement(Alert, { variant: "info" }, "Use \u2191\u2193 to navigate, Enter to edit, Ctrl+S or Esc to save"))))));
+            React.createElement(Alert, { variant: "info" }, "Use \u2191\u2193 to navigate, Enter to edit, M for manual input, Ctrl+S or Esc to save"))))));
 }

package/dist/ui/pages/WelcomeScreen.js

@@ -1,15 +1,16 @@
-import React, { useState } from 'react';
+import React, { useState, useMemo, useCallback } from 'react';
 import { Box, Text } from 'ink';
 import { Alert } from '@inkjs/ui';
 import Gradient from 'ink-gradient';
 import Menu from '../components/Menu.js';
 export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
     const [infoText, setInfoText] = useState('Start a new chat conversation');
-    const menuOptions = [
+    const menuOptions = useMemo(() => [
         {
             label: 'Start',
             value: 'chat',
-            infoText: 'Start a new chat conversation'
+            infoText: 'Start a new chat conversation',
+            clearTerminal: true
         },
         {
             label: 'API Settings',
@@ -21,27 +22,32 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
             value: 'models',
             infoText: 'Configure AI models for different tasks',
         },
+        {
+            label: 'MCP Settings',
+            value: 'mcp',
+            infoText: 'Configure Model Context Protocol servers',
+        },
         {
             label: 'Exit',
             value: 'exit',
             color: 'rgb(232, 131, 136)',
             infoText: 'Exit the application',
         }
-    ];
-    const handleSelectionChange = (newInfoText) => {
+    ], []);
+    const handleSelectionChange = useCallback((newInfoText) => {
         setInfoText(newInfoText);
-    };
+    }, []);
     return (React.createElement(Box, { flexDirection: "column", padding: 1 },
-        React.createElement(Box, { marginBottom: 2, borderStyle: "double", paddingX: 2, paddingY: 1, borderColor: 'cyan' },
+        React.createElement(Box, { borderStyle: "double", paddingX: 1, paddingY: 1, borderColor: 'cyan' },
             React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Gradient, { name: "rainbow" },
-                    React.createElement(Text, { bold: true }, "A I B O T P R O")),
-                React.createElement(Text, { color: "blue" }, "C L I"),
+                React.createElement(Text, { color: "white", bold: true },
+                    React.createElement(Text, { color: "cyan" }, "\u2746 "),
+                    React.createElement(Gradient, { name: "rainbow" }, "SNOW AI CLI")),
                 React.createElement(Text, { color: "gray", dimColor: true }, "Intelligent Command Line Assistant"),
                 React.createElement(Text, { color: "magenta", dimColor: true },
                     "Version ",
                     version))),
-        onMenuSelect && (React.createElement(Box, { marginBottom: 0 },
+        onMenuSelect && (React.createElement(Box, null,
             React.createElement(Menu, { options: menuOptions, onSelect: onMenuSelect, onSelectionChange: handleSelectionChange }))),
         React.createElement(Box, { justifyContent: "space-between" },
             React.createElement(Alert, { variant: 'info' }, infoText))));

package/dist/utils/apiConfig.d.ts

@@ -7,6 +7,15 @@ export interface ApiConfig {
     basicModel?: string;
     maxContextTokens?: number;
 }
+export interface MCPServer {
+    url?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface MCPConfig {
+    mcpServers: Record<string, MCPServer>;
+}
 export interface AppConfig {
     openai: ApiConfig;
 }
@@ -15,3 +24,6 @@ export declare function saveConfig(config: AppConfig): void;
 export declare function updateOpenAiConfig(apiConfig: Partial<ApiConfig>): void;
 export declare function getOpenAiConfig(): ApiConfig;
 export declare function validateApiConfig(config: Partial<ApiConfig>): string[];
+export declare function updateMCPConfig(mcpConfig: MCPConfig): void;
+export declare function getMCPConfig(): MCPConfig;
+export declare function validateMCPConfig(config: Partial<MCPConfig>): string[];

package/dist/utils/apiConfig.js

@@ -11,13 +11,31 @@ const DEFAULT_CONFIG = {
         maxContextTokens: 4000,
     },
 };
-const CONFIG_DIR = join(homedir(), '.aibotpro');
+const DEFAULT_MCP_CONFIG = {
+    mcpServers: {},
+};
+const CONFIG_DIR = join(homedir(), '.snow');
+function normalizeRequestMethod(method) {
+    if (method === 'chat' || method === 'responses') {
+        return method;
+    }
+    if (method === 'completions') {
+        return 'chat';
+    }
+    return DEFAULT_CONFIG.openai.requestMethod;
+}
 const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+const MCP_CONFIG_FILE = join(CONFIG_DIR, 'mcp-config.json');
 function ensureConfigDirectory() {
     if (!existsSync(CONFIG_DIR)) {
         mkdirSync(CONFIG_DIR, { recursive: true });
     }
 }
+function cloneDefaultMCPConfig() {
+    return {
+        mcpServers: { ...DEFAULT_MCP_CONFIG.mcpServers },
+    };
+}
 export function loadConfig() {
     ensureConfigDirectory();
     if (!existsSync(CONFIG_FILE)) {
@@ -26,17 +44,23 @@ export function loadConfig() {
     }
     try {
         const configData = readFileSync(CONFIG_FILE, 'utf8');
-        const config = JSON.parse(configData);
-        // Ensure backward compatibility by adding default requestMethod if missing
+        const parsedConfig = JSON.parse(configData);
+        const { mcp: legacyMcp, ...restConfig } = parsedConfig;
+        const configWithoutMcp = restConfig;
+        const mergedOpenai = {
+            ...DEFAULT_CONFIG.openai,
+            ...configWithoutMcp.openai,
+            requestMethod: DEFAULT_CONFIG.openai.requestMethod,
+        };
+        mergedOpenai.requestMethod = normalizeRequestMethod(configWithoutMcp.openai?.requestMethod);
         const mergedConfig = {
             ...DEFAULT_CONFIG,
-            ...config,
-            openai: {
-                ...DEFAULT_CONFIG.openai,
-                ...config.openai,
-                requestMethod: (config.openai?.requestMethod === 'completions' ? 'chat' : config.openai?.requestMethod) || DEFAULT_CONFIG.openai.requestMethod,
-            },
+            ...configWithoutMcp,
+            openai: mergedOpenai,
         };
+        if (legacyMcp !== undefined) {
+            saveConfig(mergedConfig);
+        }
         return mergedConfig;
     }
     catch (error) {
@@ -84,3 +108,65 @@ function isValidUrl(url) {
         return false;
     }
 }
+export function updateMCPConfig(mcpConfig) {
+    ensureConfigDirectory();
+    try {
+        const configData = JSON.stringify(mcpConfig, null, 2);
+        writeFileSync(MCP_CONFIG_FILE, configData, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Failed to save MCP configuration: ${error}`);
+    }
+}
+export function getMCPConfig() {
+    ensureConfigDirectory();
+    if (!existsSync(MCP_CONFIG_FILE)) {
+        const defaultMCPConfig = cloneDefaultMCPConfig();
+        updateMCPConfig(defaultMCPConfig);
+        return defaultMCPConfig;
+    }
+    try {
+        const configData = readFileSync(MCP_CONFIG_FILE, 'utf8');
+        const config = JSON.parse(configData);
+        return config;
+    }
+    catch (error) {
+        const defaultMCPConfig = cloneDefaultMCPConfig();
+        updateMCPConfig(defaultMCPConfig);
+        return defaultMCPConfig;
+    }
+}
+export function validateMCPConfig(config) {
+    const errors = [];
+    if (config.mcpServers) {
+        Object.entries(config.mcpServers).forEach(([name, server]) => {
+            if (!name.trim()) {
+                errors.push('Server name cannot be empty');
+            }
+            if (server.url && !isValidUrl(server.url)) {
+                const urlWithEnvReplaced = server.url.replace(/\$\{[^}]+\}|\$[A-Za-z_][A-Za-z0-9_]*/g, 'placeholder');
+                if (!isValidUrl(urlWithEnvReplaced)) {
+                    errors.push(`Invalid URL format for server "${name}"`);
+                }
+            }
+            if (server.command && !server.command.trim()) {
+                errors.push(`Command cannot be empty for server "${name}"`);
+            }
+            if (!server.url && !server.command) {
+                errors.push(`Server "${name}" must have either a URL or command`);
+            }
+            // 验证环境变量格式
+            if (server.env) {
+                Object.entries(server.env).forEach(([envName, envValue]) => {
+                    if (!envName.trim()) {
+                        errors.push(`Environment variable name cannot be empty for server "${name}"`);
+                    }
+                    if (typeof envValue !== 'string') {
+                        errors.push(`Environment variable "${envName}" must be a string for server "${name}"`);
+                    }
+                });
+            }
+        });
+    }
+    return errors;
+}

package/dist/utils/commandExecutor.d.ts

@@ -1,7 +1,8 @@
 export interface CommandResult {
     success: boolean;
     message?: string;
-    action?: 'clear' | 'info';
+    action?: 'clear' | 'resume' | 'info' | 'showMcpInfo' | 'goHome' | 'toggleYolo' | 'initProject';
+    prompt?: string;
 }
 export interface CommandHandler {
     execute: () => Promise<CommandResult> | CommandResult;

package/dist/utils/commands/init.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/utils/commands/init.js

@@ -0,0 +1,93 @@
+import { registerCommand } from '../commandExecutor.js';
+// Init command handler - Triggers AI to analyze current project and generate SNOW.md
+registerCommand('init', {
+    execute: () => {
+        return {
+            success: true,
+            action: 'initProject',
+            message: 'Starting project initialization...',
+            // Pass the optimized English prompt for AI
+            prompt: `You are an expert technical documentation specialist. Analyze the current project directory comprehensively and generate or update a SNOW.md file.
+
+**Your tasks:**
+1. Use ALL available MCP tools (filesystem, terminal) to thoroughly explore the project structure
+2. Read key files: package.json, README.md, tsconfig.json, configuration files
+3. Identify the project type, technologies, frameworks, and architecture
+4. Examine the source code structure and main modules
+5. Check for existing documentation files
+6. Generate or update SNOW.md with the following structure:
+
+# SNOW.md Structure
+
+## Project Name
+Brief one-line description
+
+## Overview
+2-3 paragraph summary of what this project does and its purpose
+
+## Technology Stack
+- Language/Runtime
+- Framework(s)
+- Key Dependencies
+- Build Tools
+
+## Project Structure
+\`\`\`
+directory tree with explanations
+\`\`\`
+
+## Key Features
+- Feature 1
+- Feature 2
+- ...
+
+## Getting Started
+
+### Prerequisites
+Required software/tools
+
+### Installation
+\`\`\`bash
+step by step commands
+\`\`\`
+
+### Usage
+Basic usage examples and commands
+
+## Development
+
+### Available Scripts
+Describe npm scripts or make targets
+
+### Development Workflow
+How to develop, test, and build
+
+## Configuration
+Explain configuration files and environment variables
+
+## Architecture
+High-level architecture overview (if complex project)
+
+## Contributing
+Guidelines for contributors (if applicable)
+
+## License
+License information (check package.json or LICENSE file)
+
+---
+
+**Important instructions:**
+- Use filesystem-list to explore directories recursively
+- Use filesystem-read to read important files
+- Use terminal-execute to run commands like 'npm run' to discover available scripts
+- Be thorough but concise - focus on essential information
+- If SNOW.md already exists, read it first and UPDATE it rather than replace
+- Format with proper Markdown syntax
+- After generating content, use filesystem-write or filesystem-create to save SNOW.md in the project root
+- Confirm completion with a brief summary
+
+Begin your analysis now. Use every tool at your disposal to understand this project completely.`
+        };
+    }
+});
+export default {};

package/dist/utils/commands/mcp.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/utils/commands/mcp.js

@@ -0,0 +1,12 @@
+import { registerCommand } from '../commandExecutor.js';
+// MCP info command handler
+registerCommand('mcp', {
+    execute: () => {
+        return {
+            success: true,
+            action: 'showMcpInfo',
+            message: 'Opening MCP services overview'
+        };
+    }
+});
+export default {};

package/dist/utils/commands/resume.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/utils/commands/resume.js

@@ -0,0 +1,12 @@
+import { registerCommand } from '../commandExecutor.js';
+// Resume command handler
+registerCommand('resume', {
+    execute: () => {
+        return {
+            success: true,
+            action: 'resume',
+            message: 'Opening session selection'
+        };
+    }
+});
+export default {};

package/dist/utils/commands/yolo.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/utils/commands/yolo.js

@@ -0,0 +1,12 @@
+import { registerCommand } from '../commandExecutor.js';
+// YOLO command handler - toggles unattended mode
+registerCommand('yolo', {
+    execute: () => {
+        return {
+            success: true,
+            action: 'toggleYolo',
+            message: 'Toggling YOLO mode'
+        };
+    }
+});
+export default {};

package/dist/utils/fileUtils.d.ts

@@ -0,0 +1,44 @@
+export interface SelectedFile {
+    path: string;
+    lineCount: number;
+    exists: boolean;
+    isImage?: boolean;
+    imageData?: string;
+    mimeType?: string;
+}
+/**
+ * Get line count for a file
+ */
+export declare function getFileLineCount(filePath: string): Promise<number>;
+/**
+ * Get file information including line count
+ */
+export declare function getFileInfo(filePath: string): Promise<SelectedFile>;
+/**
+ * Format file tree display for messages
+ */
+export declare function formatFileTree(files: SelectedFile[]): string;
+/**
+ * Parse @file references from message content and check if they exist
+ * Also supports direct file paths (pasted from VSCode drag & drop)
+ */
+export declare function parseAndValidateFileReferences(content: string): Promise<{
+    cleanContent: string;
+    validFiles: SelectedFile[];
+}>;
+/**
+ * Create message with file read instructions for AI
+ */
+export declare function createMessageWithFileInstructions(content: string, files: SelectedFile[], systemInfo?: {
+    platform: string;
+    shell: string;
+    workingDirectory: string;
+}): string;
+/**
+ * Get system information (OS, shell, working directory)
+ */
+export declare function getSystemInfo(): {
+    platform: string;
+    shell: string;
+    workingDirectory: string;
+};