snow-ai 0.4.15 → 0.4.17

package/dist/ui/pages/HeadlessModeScreen.js

@@ -1,381 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { useStdout } from 'ink';
-import ansiEscapes from 'ansi-escapes';
-import { highlight } from 'cli-highlight';
-import { handleConversationWithTools } from '../../hooks/useConversation.js';
-import { useStreamingState } from '../../hooks/useStreamingState.js';
-import { useToolConfirmation } from '../../hooks/useToolConfirmation.js';
-import { useVSCodeState } from '../../hooks/useVSCodeState.js';
-import { useSessionSave } from '../../hooks/useSessionSave.js';
-import { parseAndValidateFileReferences, createMessageWithFileInstructions, } from '../../utils/fileUtils.js';
-// Console-based markdown renderer functions
-function renderConsoleMarkdown(content) {
-    const blocks = parseConsoleMarkdown(content);
-    return blocks.map(block => renderConsoleBlock(block)).join('\n');
-}
-function parseConsoleMarkdown(content) {
-    const blocks = [];
-    const lines = content.split('\n');
-    let i = 0;
-    while (i < lines.length) {
-        const line = lines[i] ?? '';
-        // Check for code block
-        const codeBlockMatch = line.match(/^```(.*)$/);
-        if (codeBlockMatch) {
-            const language = codeBlockMatch[1]?.trim() || '';
-            const codeLines = [];
-            i++;
-            // Collect code block lines
-            while (i < lines.length) {
-                const currentLine = lines[i] ?? '';
-                if (currentLine.trim().startsWith('```')) {
-                    break;
-                }
-                codeLines.push(currentLine);
-                i++;
-            }
-            blocks.push({
-                type: 'code',
-                language,
-                code: codeLines.join('\n'),
-            });
-            i++; // Skip closing ```
-            continue;
-        }
-        // Check for heading
-        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
-        if (headingMatch) {
-            blocks.push({
-                type: 'heading',
-                level: headingMatch[1].length,
-                content: headingMatch[2].trim(),
-            });
-            i++;
-            continue;
-        }
-        // Check for list item
-        const listMatch = line.match(/^[\s]*[*\-]\s+(.+)$/);
-        if (listMatch) {
-            const listItems = [listMatch[1].trim()];
-            i++;
-            // Collect consecutive list items
-            while (i < lines.length) {
-                const currentLine = lines[i] ?? '';
-                const nextListMatch = currentLine.match(/^[\s]*[*\-]\s+(.+)$/);
-                if (!nextListMatch) {
-                    break;
-                }
-                listItems.push(nextListMatch[1].trim());
-                i++;
-            }
-            blocks.push({
-                type: 'list',
-                items: listItems,
-            });
-            continue;
-        }
-        // Collect text lines
-        const textLines = [];
-        while (i < lines.length) {
-            const currentLine = lines[i] ?? '';
-            if (currentLine.trim().startsWith('```') ||
-                currentLine.match(/^#{1,6}\s+/) ||
-                currentLine.match(/^[\s]*[*\-]\s+/)) {
-                break;
-            }
-            textLines.push(currentLine);
-            i++;
-        }
-        if (textLines.length > 0) {
-            blocks.push({
-                type: 'text',
-                content: textLines.join('\n'),
-            });
-        }
-    }
-    return blocks;
-}
-function renderConsoleBlock(block) {
-    switch (block.type) {
-        case 'code': {
-            const highlightedCode = highlightConsoleCode(block.code, block.language);
-            const languageLabel = block.language
-                ? `\x1b[42m\x1b[30m ${block.language} \x1b[0m`
-                : '';
-            return (`\n\x1b[90m┌─ Code Block\x1b[0m\n` +
-                (languageLabel ? `\x1b[90m│\x1b[0m ${languageLabel}\n` : '') +
-                `\x1b[90m├─\x1b[0m\n` +
-                `${highlightedCode}\n` +
-                `\x1b[90m└─ End of Code\x1b[0m`);
-        }
-        case 'heading': {
-            const headingColors = ['\x1b[96m', '\x1b[94m', '\x1b[95m', '\x1b[93m'];
-            const headingColor = headingColors[block.level - 1] || '\x1b[97m';
-            const prefix = '#'.repeat(block.level);
-            return `\n${headingColor}${prefix} ${renderInlineFormatting(block.content)}\x1b[0m`;
-        }
-        case 'list': {
-            return ('\n' +
-                block.items
-                    .map((item) => `\x1b[93m•\x1b[0m ${renderInlineFormatting(item)}`)
-                    .join('\n'));
-        }
-        case 'text': {
-            return ('\n' +
-                block.content
-                    .split('\n')
-                    .map((line) => line === '' ? '' : renderInlineFormatting(line))
-                    .join('\n'));
-        }
-        default:
-            return '';
-    }
-}
-function highlightConsoleCode(code, language) {
-    try {
-        if (!language) {
-            return code
-                .split('\n')
-                .map(line => `\x1b[90m│ \x1b[37m${line}\x1b[0m`)
-                .join('\n');
-        }
-        // Map common language aliases
-        const languageMap = {
-            js: 'javascript',
-            ts: 'typescript',
-            py: 'python',
-            rb: 'ruby',
-            sh: 'bash',
-            shell: 'bash',
-            cs: 'csharp',
-            'c#': 'csharp',
-            cpp: 'cpp',
-            'c++': 'cpp',
-            yml: 'yaml',
-            md: 'markdown',
-            json: 'json',
-            xml: 'xml',
-            html: 'html',
-            css: 'css',
-            sql: 'sql',
-            java: 'java',
-            go: 'go',
-            rust: 'rust',
-            php: 'php',
-        };
-        const mappedLanguage = languageMap[language.toLowerCase()] || language.toLowerCase();
-        const highlighted = highlight(code, {
-            language: mappedLanguage,
-            ignoreIllegals: true,
-        });
-        return highlighted
-            .split('\n')
-            .map(line => `\x1b[90m│ \x1b[0m${line}`)
-            .join('\n');
-    }
-    catch {
-        // If highlighting fails, return plain code
-        return code
-            .split('\n')
-            .map(line => `\x1b[90m│ \x1b[37m${line}\x1b[0m`)
-            .join('\n');
-    }
-}
-function renderInlineFormatting(text) {
-    // Handle inline code `code`
-    text = text.replace(/`([^`]+)`/g, (_, code) => {
-        return `\x1b[36m${code}\x1b[0m`;
-    });
-    // Handle bold **text** or __text__
-    text = text.replace(/(\*\*|__)([^*_]+)\1/g, (_, __, content) => {
-        return `\x1b[1m\x1b[97m${content}\x1b[0m`;
-    });
-    // Handle italic *text* or _text_
-    text = text.replace(/(?<!\*)(\*)(?!\*)([^*]+)\1(?!\*)/g, (_, __, content) => {
-        return `\x1b[3m\x1b[97m${content}\x1b[0m`;
-    });
-    return text;
-}
-export default function HeadlessModeScreen({ prompt, onComplete }) {
-    const [messages, setMessages] = useState([]);
-    const [isComplete, setIsComplete] = useState(false);
-    const { stdout } = useStdout();
-    // Use custom hooks
-    const streamingState = useStreamingState();
-    const vscodeState = useVSCodeState();
-    const { saveMessage } = useSessionSave();
-    // Use tool confirmation hook
-    const { requestToolConfirmation, isToolAutoApproved, addMultipleToAlwaysApproved, } = useToolConfirmation();
-    // Listen for message changes to display AI responses and tool calls
-    useEffect(() => {
-        const lastMessage = messages[messages.length - 1];
-        if (!lastMessage)
-            return;
-        if (lastMessage.role === 'assistant') {
-            if (lastMessage.toolPending) {
-                // Tool is being executed - use same icon as ChatScreen with colors
-                if (lastMessage.content.startsWith('⚡')) {
-                    console.log(`\n\x1b[93m⚡ ${lastMessage.content}\x1b[0m`);
-                }
-                else if (lastMessage.content.startsWith('✓')) {
-                    console.log(`\n\x1b[32m✓ ${lastMessage.content}\x1b[0m`);
-                }
-                else if (lastMessage.content.startsWith('✗')) {
-                    console.log(`\n\x1b[31m✗ ${lastMessage.content}\x1b[0m`);
-                }
-                else {
-                    console.log(`\n\x1b[96m❆ ${lastMessage.content}\x1b[0m`);
-                }
-            }
-            else if (lastMessage.content && !lastMessage.streaming) {
-                // Final response with markdown rendering and better formatting
-                console.log(renderConsoleMarkdown(lastMessage.content));
-                // Show tool results if available with better styling
-                if (lastMessage.toolCall &&
-                    lastMessage.toolCall.name === 'terminal-execute') {
-                    const args = lastMessage.toolCall.arguments;
-                    if (args.command) {
-                        console.log(`\n\x1b[90m┌─ Command\x1b[0m`);
-                        console.log(`\x1b[33m│  ${args.command}\x1b[0m`);
-                    }
-                    if (args.stdout && args.stdout.trim()) {
-                        console.log(`\x1b[90m├─ stdout\x1b[0m`);
-                        const stdoutLines = args.stdout.split('\n');
-                        stdoutLines.forEach((line) => {
-                            console.log(`\x1b[90m│  \x1b[32m${line}\x1b[0m`);
-                        });
-                    }
-                    if (args.stderr && args.stderr.trim()) {
-                        console.log(`\x1b[90m├─ stderr\x1b[0m`);
-                        const stderrLines = args.stderr.split('\n');
-                        stderrLines.forEach((line) => {
-                            console.log(`\x1b[90m│  \x1b[31m${line}\x1b[0m`);
-                        });
-                    }
-                    if (args.command || args.stdout || args.stderr) {
-                        console.log(`\x1b[90m└─ Execution complete\x1b[0m`);
-                    }
-                }
-            }
-        }
-    }, [messages]);
-    // Listen for streaming state to show loading status
-    useEffect(() => {
-        if (streamingState.isStreaming) {
-            if (streamingState.retryStatus && streamingState.retryStatus.isRetrying) {
-                // Show retry status with colors
-                if (streamingState.retryStatus.errorMessage) {
-                    console.log(`\n\x1b[31m✗ Error: ${streamingState.retryStatus.errorMessage}\x1b[0m`);
-                }
-                if (streamingState.retryStatus.remainingSeconds !== undefined &&
-                    streamingState.retryStatus.remainingSeconds > 0) {
-                    console.log(`\n\x1b[93m⟳ Retry \x1b[33m${streamingState.retryStatus.attempt}/5\x1b[93m in \x1b[32m${streamingState.retryStatus.remainingSeconds}s\x1b[93m...\x1b[0m`);
-                }
-                else {
-                    console.log(`\n\x1b[93m⟳ Resending... \x1b[33m(Attempt ${streamingState.retryStatus.attempt}/5)\x1b[0m`);
-                }
-            }
-            else {
-                // Show normal thinking status with colors
-                const thinkingText = streamingState.isReasoning
-                    ? 'Deep thinking...'
-                    : streamingState.streamTokenCount > 0
-                        ? 'Writing...'
-                        : 'Thinking...';
-                process.stdout.write(`\r\x1b[96m❆\x1b[90m ${thinkingText} \x1b[37m(\x1b[33m${streamingState.elapsedSeconds}s\x1b[37m · \x1b[32m↓ ${streamingState.streamTokenCount} tokens\x1b[37m)\x1b[0m`);
-            }
-        }
-    }, [
-        streamingState.isStreaming,
-        streamingState.isReasoning,
-        streamingState.elapsedSeconds,
-        streamingState.streamTokenCount,
-        streamingState.retryStatus,
-    ]);
-    const processMessage = async () => {
-        try {
-            // Parse and validate file references
-            const { cleanContent, validFiles } = await parseAndValidateFileReferences(prompt);
-            const regularFiles = validFiles.filter(f => !f.isImage);
-            // Add user message to UI
-            const userMessage = {
-                role: 'user',
-                content: cleanContent,
-                files: validFiles.length > 0 ? validFiles : undefined,
-            };
-            setMessages([userMessage]);
-            streamingState.setIsStreaming(true);
-            // Create new abort controller for this request
-            const controller = new AbortController();
-            streamingState.setAbortController(controller);
-            // Clear terminal and start headless output
-            stdout.write(ansiEscapes.clearTerminal);
-            // Print colorful banner
-            console.log(`\x1b[94m╭─────────────────────────────────────────────────────────╮\x1b[0m`);
-            console.log(`\x1b[94m│\x1b[96m                ❆ Snow AI CLI - Headless Mode ❆          \x1b[94m│\x1b[0m`);
-            console.log(`\x1b[94m╰─────────────────────────────────────────────────────────╯\x1b[0m`);
-            // Print user prompt with styling
-            console.log(`\n\x1b[36m┌─ User Query\x1b[0m`);
-            console.log(`\x1b[97m│  ${cleanContent}\x1b[0m`);
-            if (validFiles.length > 0) {
-                console.log(`\x1b[36m├─ Files\x1b[0m`);
-                validFiles.forEach(file => {
-                    const statusColor = file.exists ? '\x1b[32m' : '\x1b[31m';
-                    const statusText = file.exists ? '✓' : '✗';
-                    console.log(`\x1b[90m│  └─ ${statusColor}${statusText}\x1b[90m ${file.path}${file.exists
-                        ? `\x1b[33m (${file.lineCount} lines)\x1b[90m`
-                        : '\x1b[31m (not found)\x1b[90m'}\x1b[0m`);
-                });
-            }
-            console.log(`\x1b[36m└─ Assistant Response\x1b[0m`);
-            // Create message for AI
-            const messageForAI = createMessageWithFileInstructions(cleanContent, regularFiles, vscodeState.vscodeConnected ? vscodeState.editorContext : undefined);
-            // Start conversation with tool support
-            await handleConversationWithTools({
-                userContent: messageForAI,
-                imageContents: [],
-                controller,
-                messages,
-                saveMessage,
-                setMessages,
-                setStreamTokenCount: streamingState.setStreamTokenCount,
-                requestToolConfirmation,
-                isToolAutoApproved,
-                addMultipleToAlwaysApproved,
-                yoloMode: true, // Always use YOLO mode in headless
-                setContextUsage: streamingState.setContextUsage,
-                useBasicModel: false,
-                getPendingMessages: () => [],
-                clearPendingMessages: () => { },
-                setIsStreaming: streamingState.setIsStreaming,
-                setIsReasoning: streamingState.setIsReasoning,
-                setRetryStatus: streamingState.setRetryStatus,
-            });
-        }
-        catch (error) {
-            console.error(`\n\x1b[31m✗ Error:\x1b[0m`, error instanceof Error
-                ? `\x1b[91m${error.message}\x1b[0m`
-                : '\x1b[91mUnknown error occurred\x1b[0m');
-        }
-        finally {
-            // End streaming
-            streamingState.setIsStreaming(false);
-            streamingState.setAbortController(null);
-            streamingState.setStreamTokenCount(0);
-            setIsComplete(true);
-            // Wait a moment then call onComplete
-            setTimeout(() => {
-                onComplete();
-            }, 1000);
-        }
-    };
-    useEffect(() => {
-        processMessage();
-    }, []);
-    // Simple console output mode - don't render anything
-    if (isComplete) {
-        return null;
-    }
-    // Return empty fragment - we're using console.log for output
-    return React.createElement(React.Fragment, null);
-}

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

@@ -1,7 +0,0 @@
-import React from 'react';
-type Props = {
-    onBack: () => void;
-    inlineMode?: boolean;
-};
-export default function LanguageSettingsScreen({ onBack, inlineMode, }: Props): React.JSX.Element;
-export {};

package/dist/ui/pages/LanguageSettingsScreen.js

@@ -1,91 +0,0 @@
-import React, { useState, useCallback } from 'react';
-import { Box, Text, useInput } from 'ink';
-import Menu from '../components/Menu.js';
-import { useI18n } from '../../i18n/index.js';
-import { useTheme } from '../contexts/ThemeContext.js';
-export default function LanguageSettingsScreen({ onBack, inlineMode = false, }) {
-    const { language, setLanguage } = useI18n();
-    const { theme } = useTheme();
-    const [selectedLanguage, setSelectedLanguage] = useState(language);
-    const languageOptions = [
-        {
-            label: 'English',
-            value: 'en',
-            infoText: 'Switch to English',
-        },
-        {
-            label: '简体中文',
-            value: 'zh',
-            infoText: '切换到简体中文',
-        },
-        {
-            label: '繁體中文',
-            value: 'zh-TW',
-            infoText: '切換到繁體中文',
-        },
-        {
-            label: '日本語',
-            value: 'ja',
-            infoText: '日本語に切り替え',
-        },
-        {
-            label: '한국어',
-            value: 'ko',
-            infoText: '한국어로 전환',
-        },
-        {
-            label: 'Español',
-            value: 'es',
-            infoText: 'Cambiar a Español',
-        },
-        {
-            label: '← Back',
-            value: 'back',
-            color: theme.colors.menuSecondary,
-            infoText: 'Return to main menu',
-        },
-    ];
-    const handleSelect = useCallback((value) => {
-        if (value === 'back') {
-            onBack();
-        }
-        else {
-            const newLang = value;
-            setSelectedLanguage(newLang);
-            setLanguage(newLang);
-            // Auto return to menu after selection
-            setTimeout(() => {
-                onBack();
-            }, 300);
-        }
-    }, [onBack, setLanguage]);
-    const handleSelectionChange = useCallback((_infoText) => {
-        // Could update some info display here if needed
-    }, []);
-    useInput((_input, key) => {
-        if (key.escape) {
-            onBack();
-        }
-    });
-    return (React.createElement(Box, { flexDirection: "column", paddingX: 1 },
-        !inlineMode && (React.createElement(Box, { borderStyle: "round", borderColor: theme.colors.menuInfo, paddingX: 1, marginBottom: 1 },
-            React.createElement(Box, { flexDirection: "column" },
-                React.createElement(Text, { bold: true, color: theme.colors.menuInfo }, "Language Settings / \u8BED\u8A00\u8BBE\u7F6E")))),
-        React.createElement(Box, { flexDirection: "column" },
-            React.createElement(Box, { paddingX: 1 },
-                React.createElement(Text, { color: theme.colors.menuSecondary, dimColor: true },
-                    "Current:",
-                    ' ',
-                    selectedLanguage === 'en'
-                        ? 'English'
-                        : selectedLanguage === 'zh'
-                            ? '简体中文'
-                            : selectedLanguage === 'zh-TW'
-                                ? '繁體中文'
-                                : selectedLanguage === 'ja'
-                                    ? '日本語'
-                                    : selectedLanguage === 'ko'
-                                        ? '한국어'
-                                        : 'Español')),
-            React.createElement(Menu, { options: languageOptions, onSelect: handleSelect, onSelectionChange: handleSelectionChange }))));
-}

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

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

package/dist/ui/pages/MCPConfigScreen.js

@@ -1,55 +0,0 @@
-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/ProxyConfigScreen.d.ts

@@ -1,8 +0,0 @@
-import React from 'react';
-type Props = {
-    onBack: () => void;
-    onSave: () => void;
-    inlineMode?: boolean;
-};
-export default function ProxyConfigScreen({ onBack, onSave, inlineMode, }: Props): React.JSX.Element;
-export {};