snow-ai 0.2.2 → 0.2.4

package/dist/api/responses.js

@@ -476,7 +476,7 @@ export async function createResponseWithTools(options, maxToolRounds = 5) {
                 reasoning: options.reasoning || { summary: 'auto', effort: 'high' },
                 store: options.store ?? false, // 默认不存储对话历史，提高缓存命中
                 include: options.include || ['reasoning.encrypted_content'], // 包含加密推理内容
-                prompt_cache_key: options.prompt_cache_key, // 缓存键（可选）
+                prompt_cache_key: options.prompt_cache_key, // 缓存键
             });
             const output = response.output;
             if (!output || output.length === 0) {

package/dist/app.js

@@ -1,5 +1,5 @@
 import React, { useState, useEffect } from 'react';
-import { Box, Text } from 'ink';
+import { Box, Text, useStdout } from 'ink';
 import { Alert } from '@inkjs/ui';
 import WelcomeScreen from './ui/pages/WelcomeScreen.js';
 import ApiConfigScreen from './ui/pages/ApiConfigScreen.js';
@@ -14,6 +14,9 @@ export default function App({ version }) {
         show: false,
         message: ''
     });
+    // Terminal resize handling - force re-render on resize
+    const { stdout } = useStdout();
+    const [terminalSize, setTerminalSize] = useState({ columns: stdout?.columns || 80, rows: stdout?.rows || 24 });
     // Global exit handler
     useGlobalExit(setExitNotification);
     // Global navigation handler
@@ -23,6 +26,26 @@ export default function App({ version }) {
         });
         return unsubscribe;
     }, []);
+    // Terminal resize listener with debounce
+    useEffect(() => {
+        if (!stdout)
+            return;
+        let resizeTimeout;
+        const handleResize = () => {
+            // Debounce resize events - wait for resize to stabilize
+            clearTimeout(resizeTimeout);
+            resizeTimeout = setTimeout(() => {
+                // Clear screen before re-render
+                stdout.write('\x1Bc'); // Full reset
+                setTerminalSize({ columns: stdout.columns, rows: stdout.rows });
+            }, 100); // 100ms debounce
+        };
+        stdout.on('resize', handleResize);
+        return () => {
+            stdout.off('resize', handleResize);
+            clearTimeout(resizeTimeout);
+        };
+    }, [stdout]);
     const handleMenuSelect = (value) => {
         if (value === 'chat' || value === 'settings' || value === 'config' || value === 'models' || value === 'mcp') {
             setCurrentView(value);
@@ -51,7 +74,7 @@ export default function App({ version }) {
                 return (React.createElement(WelcomeScreen, { version: version, onMenuSelect: handleMenuSelect }));
         }
     };
-    return (React.createElement(Box, { flexDirection: "column" },
+    return (React.createElement(Box, { flexDirection: "column", key: `term-${terminalSize.columns}x${terminalSize.rows}` },
         renderView(),
         exitNotification.show && (React.createElement(Box, { paddingX: 1 },
             React.createElement(Alert, { variant: "warning" }, exitNotification.message)))));

package/dist/mcp/filesystem.d.ts

@@ -1,3 +1,4 @@
+import { type Diagnostic } from '../utils/vscodeConnection.js';
 interface SearchMatch {
     filePath: string;
     lineNumber: number;
@@ -90,6 +91,7 @@ export declare class FilesystemMCPService {
         contextStartLine: number;
         contextEndLine: number;
         totalLines: number;
+        diagnostics?: Diagnostic[];
     }>;
     /**
      * Search for code keywords in files within a directory

package/dist/mcp/filesystem.js

@@ -1,5 +1,6 @@
 import { promises as fs } from 'fs';
 import * as path from 'path';
+import { vscodeConnection } from '../utils/vscodeConnection.js';
 const { resolve, dirname, isAbsolute } = path;
 /**
  * Filesystem MCP Service
@@ -251,7 +252,17 @@ export class FilesystemMCPService {
             const newContextContent = newContextLines.join('\n');
             // Write the modified content back to file
             await fs.writeFile(fullPath, modifiedLines.join('\n'), 'utf-8');
-            return {
+            // Try to get diagnostics from VS Code after editing
+            let diagnostics = [];
+            try {
+                // Wait a bit for VS Code to process the file change
+                await new Promise(resolve => setTimeout(resolve, 500));
+                diagnostics = await vscodeConnection.requestDiagnostics(fullPath);
+            }
+            catch (error) {
+                // Ignore diagnostics errors, they are optional
+            }
+            const result = {
                 message: `File edited successfully: ${filePath} (lines ${startLine}-${adjustedEndLine} replaced)`,
                 oldContent,
                 newContent: newContextContent,
@@ -259,6 +270,16 @@ export class FilesystemMCPService {
                 contextEndLine: newContextEnd,
                 totalLines: newTotalLines
             };
+            // Add diagnostics if any were found
+            if (diagnostics.length > 0) {
+                result.diagnostics = diagnostics;
+                const errorCount = diagnostics.filter(d => d.severity === 'error').length;
+                const warningCount = diagnostics.filter(d => d.severity === 'warning').length;
+                if (errorCount > 0 || warningCount > 0) {
+                    result.message += `\n\n⚠️  Diagnostics detected: ${errorCount} error(s), ${warningCount} warning(s)`;
+                }
+            }
+            return result;
         }
         catch (error) {
             throw new Error(`Failed to edit file ${filePath}: ${error instanceof Error ? error.message : 'Unknown error'}`);

package/dist/ui/components/ChatInput.js

@@ -12,7 +12,9 @@ const commands = [
     { name: 'resume', description: 'Resume a conversation' },
     { name: 'mcp', description: 'Show Model Context Protocol services and tools' },
     { name: 'yolo', description: 'Toggle unattended mode (auto-approve all tools)' },
-    { name: 'init', description: 'Analyze project and generate/update SNOW.md documentation' }
+    { name: 'init', description: 'Analyze project and generate/update SNOW.md documentation' },
+    { name: 'ide', description: 'Connect to VSCode editor and sync context' },
+    { name: 'compact', description: 'Compress conversation history using compact model' }
 ];
 export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type your message...', disabled = false, chatHistory = [], onHistorySelect, yoloMode = false, contextUsage }) {
     const { stdout } = useStdout();

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

@@ -4,6 +4,8 @@ import '../../utils/commands/resume.js';
 import '../../utils/commands/mcp.js';
 import '../../utils/commands/yolo.js';
 import '../../utils/commands/init.js';
+import '../../utils/commands/ide.js';
+import '../../utils/commands/compact.js';
 type Props = {};
 export default function ChatScreen({}: Props): React.JSX.Element;
 export {};

package/dist/ui/pages/ChatScreen.js

@@ -18,13 +18,17 @@ import { useSessionManagement } from '../../hooks/useSessionManagement.js';
 import { useToolConfirmation } from '../../hooks/useToolConfirmation.js';
 import { handleConversationWithTools } from '../../hooks/useConversation.js';
 import { parseAndValidateFileReferences, createMessageWithFileInstructions, getSystemInfo } from '../../utils/fileUtils.js';
+import { compressContext } from '../../utils/contextCompressor.js';
 // Import commands to register them
 import '../../utils/commands/clear.js';
 import '../../utils/commands/resume.js';
 import '../../utils/commands/mcp.js';
 import '../../utils/commands/yolo.js';
 import '../../utils/commands/init.js';
+import '../../utils/commands/ide.js';
+import '../../utils/commands/compact.js';
 import { navigateTo } from '../../hooks/useGlobalNavigation.js';
+import { vscodeConnection } from '../../utils/vscodeConnection.js';
 // Format elapsed time to human readable format
 function formatElapsedTime(seconds) {
     if (seconds < 60) {
@@ -59,6 +63,11 @@ export default function ChatScreen({}) {
     const [contextUsage, setContextUsage] = useState(null);
     const [elapsedSeconds, setElapsedSeconds] = useState(0);
     const [timerStartTime, setTimerStartTime] = useState(null);
+    const [vscodeConnected, setVscodeConnected] = useState(false);
+    const [vscodeConnectionStatus, setVscodeConnectionStatus] = useState('disconnected');
+    const [editorContext, setEditorContext] = useState({});
+    const [isCompressing, setIsCompressing] = useState(false);
+    const [compressionError, setCompressionError] = useState(null);
     const { stdout } = useStdout();
     const workingDirectory = process.cwd();
     // Use session save hook
@@ -105,6 +114,60 @@ export default function ChatScreen({}) {
         }, 1000);
         return () => clearInterval(interval);
     }, [timerStartTime]);
+    // Monitor VSCode connection status and editor context
+    useEffect(() => {
+        let connectingTimeout = null;
+        const checkConnection = setInterval(() => {
+            const isConnected = vscodeConnection.isConnected();
+            const isServerRunning = vscodeConnection.isServerRunning();
+            setVscodeConnected(isConnected);
+            // Update connection status based on actual connection state
+            if (isConnected && vscodeConnectionStatus !== 'connected') {
+                setVscodeConnectionStatus('connected');
+                if (connectingTimeout) {
+                    clearTimeout(connectingTimeout);
+                    connectingTimeout = null;
+                }
+            }
+            else if (!isConnected && vscodeConnectionStatus === 'connected') {
+                setVscodeConnectionStatus('disconnected');
+            }
+            else if (vscodeConnectionStatus === 'connecting' && !isServerRunning) {
+                // Server failed to start
+                setVscodeConnectionStatus('error');
+                if (connectingTimeout) {
+                    clearTimeout(connectingTimeout);
+                    connectingTimeout = null;
+                }
+            }
+        }, 1000);
+        // Set timeout for connecting state (15 seconds)
+        if (vscodeConnectionStatus === 'connecting') {
+            connectingTimeout = setTimeout(() => {
+                if (vscodeConnectionStatus === 'connecting') {
+                    setVscodeConnectionStatus('error');
+                }
+            }, 15000);
+        }
+        const unsubscribe = vscodeConnection.onContextUpdate((context) => {
+            setEditorContext(context);
+            // When we receive context, it means connection is successful
+            if (vscodeConnectionStatus !== 'connected') {
+                setVscodeConnectionStatus('connected');
+                if (connectingTimeout) {
+                    clearTimeout(connectingTimeout);
+                    connectingTimeout = null;
+                }
+            }
+        });
+        return () => {
+            clearInterval(checkConnection);
+            if (connectingTimeout) {
+                clearTimeout(connectingTimeout);
+            }
+            unsubscribe();
+        };
+    }, [vscodeConnectionStatus]);
     // Pending messages are now handled inline during tool execution in useConversation
     // Auto-send pending messages when streaming completely stops (as fallback)
     useEffect(() => {
@@ -140,7 +203,74 @@ export default function ChatScreen({}) {
             setStreamTokenCount(0);
         }
     });
-    const handleCommandExecution = (commandName, result) => {
+    const handleCommandExecution = async (commandName, result) => {
+        // Handle /compact command
+        if (commandName === 'compact' && result.success && result.action === 'compact') {
+            // Set compressing state (不添加命令面板消息)
+            setIsCompressing(true);
+            setCompressionError(null);
+            try {
+                // Convert messages to ChatMessage format for compression
+                const chatMessages = messages
+                    .filter(msg => msg.role !== 'command')
+                    .map(msg => ({
+                    role: msg.role,
+                    content: msg.content,
+                    tool_call_id: msg.toolCallId
+                }));
+                // Compress the context
+                const result = await compressContext(chatMessages);
+                // Replace all messages with a summary message (不包含 "Context Compressed" 标题)
+                const summaryMessage = {
+                    role: 'assistant',
+                    content: result.summary,
+                    streaming: false
+                };
+                // Clear session and set new compressed state
+                sessionManager.clearCurrentSession();
+                clearSavedMessages();
+                setMessages([summaryMessage]);
+                setRemountKey(prev => prev + 1);
+                // Update token usage with compression result
+                setContextUsage({
+                    prompt_tokens: result.usage.prompt_tokens,
+                    completion_tokens: result.usage.completion_tokens,
+                    total_tokens: result.usage.total_tokens
+                });
+            }
+            catch (error) {
+                // Show error message
+                const errorMsg = error instanceof Error ? error.message : 'Unknown compression error';
+                setCompressionError(errorMsg);
+                const errorMessage = {
+                    role: 'assistant',
+                    content: `**Compression Failed**\n\n${errorMsg}`,
+                    streaming: false
+                };
+                setMessages(prev => [...prev, errorMessage]);
+            }
+            finally {
+                setIsCompressing(false);
+            }
+            return;
+        }
+        // Handle /ide command
+        if (commandName === 'ide') {
+            if (result.success) {
+                setVscodeConnectionStatus('connecting');
+                // Add command execution feedback
+                const commandMessage = {
+                    role: 'command',
+                    content: '',
+                    commandName: commandName
+                };
+                setMessages(prev => [...prev, commandMessage]);
+            }
+            else {
+                setVscodeConnectionStatus('error');
+            }
+            return;
+        }
         if (result.success && result.action === 'clear') {
             if (stdout && typeof stdout.write === 'function') {
                 stdout.write('\x1B[3J\x1B[2J\x1B[H');
@@ -241,8 +371,8 @@ export default function ChatScreen({}) {
         const controller = new AbortController();
         setAbortController(controller);
         try {
-            // Create message for AI with file read instructions and system info
-            const messageForAI = createMessageWithFileInstructions(cleanContent, regularFiles, systemInfo);
+            // Create message for AI with file read instructions, system info, and editor context
+            const messageForAI = createMessageWithFileInstructions(cleanContent, regularFiles, systemInfo, vscodeConnected ? editorContext : undefined);
             // Start conversation with tool support
             await handleConversationWithTools({
                 userContent: messageForAI,
@@ -469,8 +599,27 @@ export default function ChatScreen({}) {
         React.createElement(Box, { marginX: 1 },
             React.createElement(PendingMessages, { pendingMessages: pendingMessages })),
         pendingToolConfirmation && (React.createElement(ToolConfirmation, { toolName: pendingToolConfirmation.batchToolNames || pendingToolConfirmation.tool.function.name, onConfirm: pendingToolConfirmation.resolve })),
-        !pendingToolConfirmation && (React.createElement(ChatInput, { onSubmit: handleMessageSubmit, onCommand: handleCommandExecution, placeholder: "Ask me anything about coding...", disabled: !!pendingToolConfirmation, chatHistory: messages, onHistorySelect: handleHistorySelect, yoloMode: yoloMode, contextUsage: contextUsage ? {
-                inputTokens: contextUsage.prompt_tokens,
-                maxContextTokens: getOpenAiConfig().maxContextTokens || 4000
-            } : undefined }))));
+        !pendingToolConfirmation && !isCompressing && (React.createElement(React.Fragment, null,
+            React.createElement(ChatInput, { onSubmit: handleMessageSubmit, onCommand: handleCommandExecution, placeholder: "Ask me anything about coding...", disabled: !!pendingToolConfirmation, chatHistory: messages, onHistorySelect: handleHistorySelect, yoloMode: yoloMode, contextUsage: contextUsage ? {
+                    inputTokens: contextUsage.prompt_tokens,
+                    maxContextTokens: getOpenAiConfig().maxContextTokens || 4000
+                } : undefined }),
+            vscodeConnectionStatus !== 'disconnected' && (React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: vscodeConnectionStatus === 'connecting' ? 'yellow' :
+                        vscodeConnectionStatus === 'connected' ? 'green' :
+                            vscodeConnectionStatus === 'error' ? 'red' : 'gray', dimColor: vscodeConnectionStatus !== 'error' },
+                    "\u25CF ",
+                    vscodeConnectionStatus === 'connecting' ? 'Connecting to VSCode...' :
+                        vscodeConnectionStatus === 'connected' ? 'VSCode Connected' :
+                            vscodeConnectionStatus === 'error' ? 'Connection Failed' : 'VSCode',
+                    vscodeConnectionStatus === 'connected' && editorContext.activeFile && ` | ${editorContext.activeFile}`,
+                    vscodeConnectionStatus === 'connected' && editorContext.selectedText && ` | ${editorContext.selectedText.length} chars selected`))))),
+        isCompressing && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "cyan" },
+                React.createElement(Spinner, { type: "dots" }),
+                " Compressing conversation history..."))),
+        compressionError && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "red" },
+                "\u2717 Compression failed: ",
+                compressionError)))));
 }

package/dist/ui/pages/ModelConfigScreen.js

@@ -8,6 +8,9 @@ export default function ModelConfigScreen({ onBack, onSave }) {
     const [advancedModel, setAdvancedModel] = useState('');
     const [basicModel, setBasicModel] = useState('');
     const [maxContextTokens, setMaxContextTokens] = useState(4000);
+    const [compactBaseUrl, setCompactBaseUrl] = useState('');
+    const [compactApiKey, setCompactApiKey] = useState('');
+    const [compactModelName, setCompactModelName] = useState('');
     const [currentField, setCurrentField] = useState('advancedModel');
     const [isEditing, setIsEditing] = useState(false);
     const [models, setModels] = useState([]);
@@ -21,6 +24,9 @@ export default function ModelConfigScreen({ onBack, onSave }) {
         setAdvancedModel(config.advancedModel || '');
         setBasicModel(config.basicModel || '');
         setMaxContextTokens(config.maxContextTokens || 4000);
+        setCompactBaseUrl(config.compactModel?.baseUrl || '');
+        setCompactApiKey(config.compactModel?.apiKey || '');
+        setCompactModelName(config.compactModel?.modelName || '');
         if (!config.baseUrl) {
             setBaseUrlMissing(true);
             return;
@@ -57,7 +63,15 @@ export default function ModelConfigScreen({ onBack, onSave }) {
             return advancedModel;
         if (currentField === 'basicModel')
             return basicModel;
-        return maxContextTokens.toString();
+        if (currentField === 'maxContextTokens')
+            return maxContextTokens.toString();
+        if (currentField === 'compactBaseUrl')
+            return compactBaseUrl;
+        if (currentField === 'compactApiKey')
+            return compactApiKey;
+        if (currentField === 'compactModelName')
+            return compactModelName;
+        return '';
     };
     const handleModelChange = (value) => {
         // 如果选择了手动输入选项
@@ -146,6 +160,34 @@ export default function ModelConfigScreen({ onBack, onSave }) {
                     setIsEditing(false);
                 }
             }
+            else if (currentField === 'compactBaseUrl' || currentField === 'compactApiKey' || currentField === 'compactModelName') {
+                // Handle text input for compact model fields
+                if (key.return) {
+                    setIsEditing(false);
+                }
+                else if (key.backspace || key.delete) {
+                    if (currentField === 'compactBaseUrl') {
+                        setCompactBaseUrl(prev => prev.slice(0, -1));
+                    }
+                    else if (currentField === 'compactApiKey') {
+                        setCompactApiKey(prev => prev.slice(0, -1));
+                    }
+                    else if (currentField === 'compactModelName') {
+                        setCompactModelName(prev => prev.slice(0, -1));
+                    }
+                }
+                else if (input && input.match(/[a-zA-Z0-9-_./:]/)) {
+                    if (currentField === 'compactBaseUrl') {
+                        setCompactBaseUrl(prev => prev + input);
+                    }
+                    else if (currentField === 'compactApiKey') {
+                        setCompactApiKey(prev => prev + input);
+                    }
+                    else if (currentField === 'compactModelName') {
+                        setCompactModelName(prev => prev + input);
+                    }
+                }
+            }
             else {
                 // Allow typing to filter in edit mode for model selection
                 if (input && input.match(/[a-zA-Z0-9-_.]/)) {
@@ -164,6 +206,14 @@ export default function ModelConfigScreen({ onBack, onSave }) {
                 basicModel,
                 maxContextTokens,
             };
+            // 只有当所有字段都填写时才保存 compactModel
+            if (compactBaseUrl && compactApiKey && compactModelName) {
+                config.compactModel = {
+                    baseUrl: compactBaseUrl,
+                    apiKey: compactApiKey,
+                    modelName: compactModelName,
+                };
+            }
             updateOpenAiConfig(config);
             onSave();
         }
@@ -173,13 +223,22 @@ export default function ModelConfigScreen({ onBack, onSave }) {
                 basicModel,
                 maxContextTokens,
             };
+            // 只有当所有字段都填写时才保存 compactModel
+            if (compactBaseUrl && compactApiKey && compactModelName) {
+                config.compactModel = {
+                    baseUrl: compactBaseUrl,
+                    apiKey: compactApiKey,
+                    modelName: compactModelName,
+                };
+            }
             updateOpenAiConfig(config);
             onBack();
         }
         else if (key.return) {
-            // Load models first for model fields, or enter edit mode directly for maxContextTokens
+            // Load models first for model fields, or enter edit mode directly for maxContextTokens and compact fields
             setSearchTerm(''); // Reset search when entering edit mode
-            if (currentField === 'maxContextTokens') {
+            const isCompactField = currentField === 'compactBaseUrl' || currentField === 'compactApiKey' || currentField === 'compactModelName';
+            if (currentField === 'maxContextTokens' || isCompactField) {
                 setIsEditing(true);
             }
             else {
@@ -194,7 +253,8 @@ export default function ModelConfigScreen({ onBack, onSave }) {
         }
         else if (input === 'm') {
             // 快捷键：按 'm' 直接进入手动输入模式
-            if (currentField !== 'maxContextTokens') {
+            const isCompactField = currentField === 'compactBaseUrl' || currentField === 'compactApiKey' || currentField === 'compactModelName';
+            if (currentField !== 'maxContextTokens' && !isCompactField) {
                 setManualInputMode(true);
                 setManualInputValue(getCurrentValue());
             }
@@ -206,6 +266,15 @@ export default function ModelConfigScreen({ onBack, onSave }) {
             else if (currentField === 'maxContextTokens') {
                 setCurrentField('basicModel');
             }
+            else if (currentField === 'compactBaseUrl') {
+                setCurrentField('maxContextTokens');
+            }
+            else if (currentField === 'compactApiKey') {
+                setCurrentField('compactBaseUrl');
+            }
+            else if (currentField === 'compactModelName') {
+                setCurrentField('compactApiKey');
+            }
         }
         else if (key.downArrow) {
             if (currentField === 'advancedModel') {
@@ -214,6 +283,15 @@ export default function ModelConfigScreen({ onBack, onSave }) {
             else if (currentField === 'basicModel') {
                 setCurrentField('maxContextTokens');
             }
+            else if (currentField === 'maxContextTokens') {
+                setCurrentField('compactBaseUrl');
+            }
+            else if (currentField === 'compactBaseUrl') {
+                setCurrentField('compactApiKey');
+            }
+            else if (currentField === 'compactApiKey') {
+                setCurrentField('compactModelName');
+            }
         }
     });
     if (baseUrlMissing) {
@@ -293,7 +371,42 @@ export default function ModelConfigScreen({ onBack, onSave }) {
                             "Enter value: ",
                             maxContextTokens))),
                     (!isEditing || currentField !== 'maxContextTokens') && (React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: "gray" }, maxContextTokens)))))),
+                        React.createElement(Text, { color: "gray" }, maxContextTokens))))),
+            React.createElement(Box, { marginBottom: 2, marginTop: 1 },
+                React.createElement(Text, { color: "cyan", bold: true }, "Compact Model (Context Compression):")),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: currentField === 'compactBaseUrl' ? 'green' : 'white' },
+                        currentField === 'compactBaseUrl' ? '➣ ' : '  ',
+                        "Base URL:"),
+                    currentField === 'compactBaseUrl' && isEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            compactBaseUrl,
+                            React.createElement(Text, { color: "white" }, "_")))),
+                    (!isEditing || currentField !== 'compactBaseUrl') && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, compactBaseUrl || 'Not set'))))),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: currentField === 'compactApiKey' ? 'green' : 'white' },
+                        currentField === 'compactApiKey' ? '➣ ' : '  ',
+                        "API Key:"),
+                    currentField === 'compactApiKey' && isEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            compactApiKey.replace(/./g, '*'),
+                            React.createElement(Text, { color: "white" }, "_")))),
+                    (!isEditing || currentField !== 'compactApiKey') && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, compactApiKey ? compactApiKey.replace(/./g, '*') : 'Not set'))))),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: currentField === 'compactModelName' ? 'green' : 'white' },
+                        currentField === 'compactModelName' ? '➣ ' : '  ',
+                        "Model Name:"),
+                    currentField === 'compactModelName' && isEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            compactModelName,
+                            React.createElement(Text, { color: "white" }, "_")))),
+                    (!isEditing || currentField !== 'compactModelName') && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, compactModelName || 'Not set')))))),
         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, M for manual input, Ctrl+S or Esc to save"))))));

package/dist/utils/apiConfig.d.ts

@@ -1,4 +1,9 @@
 export type RequestMethod = 'chat' | 'responses';
+export interface CompactModelConfig {
+    baseUrl: string;
+    apiKey: string;
+    modelName: string;
+}
 export interface ApiConfig {
     baseUrl: string;
     apiKey: string;
@@ -6,6 +11,7 @@ export interface ApiConfig {
     advancedModel?: string;
     basicModel?: string;
     maxContextTokens?: number;
+    compactModel?: CompactModelConfig;
 }
 export interface MCPServer {
     url?: string;

package/dist/utils/commandExecutor.d.ts

@@ -1,7 +1,7 @@
 export interface CommandResult {
     success: boolean;
     message?: string;
-    action?: 'clear' | 'resume' | 'info' | 'showMcpInfo' | 'goHome' | 'toggleYolo' | 'initProject';
+    action?: 'clear' | 'resume' | 'info' | 'showMcpInfo' | 'goHome' | 'toggleYolo' | 'initProject' | 'compact';
     prompt?: string;
 }
 export interface CommandHandler {

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

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

package/dist/utils/commands/compact.js

@@ -0,0 +1,12 @@
+import { registerCommand } from '../commandExecutor.js';
+// Compact command handler - compress conversation history
+registerCommand('compact', {
+    execute: () => {
+        return {
+            success: true,
+            action: 'compact',
+            message: 'Compressing conversation history...'
+        };
+    }
+});
+export default {};

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

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

package/dist/utils/commands/ide.js

@@ -0,0 +1,29 @@
+import { registerCommand } from '../commandExecutor.js';
+import { vscodeConnection } from '../vscodeConnection.js';
+// IDE connection command handler
+registerCommand('ide', {
+    execute: async () => {
+        if (vscodeConnection.isConnected()) {
+            return {
+                success: true,
+                action: 'info',
+                message: 'Already connected to VSCode editor'
+            };
+        }
+        try {
+            await vscodeConnection.start();
+            return {
+                success: true,
+                action: 'info',
+                message: `VSCode connection server started on port ${vscodeConnection.getPort()}\nPlease connect from the Snow CLI extension in VSCode`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : 'Failed to start IDE connection'
+            };
+        }
+    }
+});
+export default {};

package/dist/utils/contextCompressor.d.ts

@@ -0,0 +1,15 @@
+import type { ChatMessage } from '../api/chat.js';
+export interface CompressionResult {
+    summary: string;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+/**
+ * Compress conversation history using the compact model
+ * @param messages - Array of messages to compress
+ * @returns Compressed summary and token usage information
+ */
+export declare function compressContext(messages: ChatMessage[]): Promise<CompressionResult>;

package/dist/utils/contextCompressor.js

@@ -0,0 +1,69 @@
+import OpenAI from 'openai';
+import { getOpenAiConfig } from './apiConfig.js';
+/**
+ * Compress conversation history using the compact model
+ * @param messages - Array of messages to compress
+ * @returns Compressed summary and token usage information
+ */
+export async function compressContext(messages) {
+    const config = getOpenAiConfig();
+    // Check if compact model is configured
+    if (!config.compactModel || !config.compactModel.baseUrl || !config.compactModel.apiKey || !config.compactModel.modelName) {
+        throw new Error('Compact model not configured. Please configure it in Model Settings.');
+    }
+    // Create OpenAI client with compact model config
+    const client = new OpenAI({
+        apiKey: config.compactModel.apiKey,
+        baseURL: config.compactModel.baseUrl,
+    });
+    // Filter out system messages and create a conversation text
+    const conversationText = messages
+        .filter(msg => msg.role !== 'system')
+        .map(msg => {
+        const role = msg.role === 'user' ? 'User' : msg.role === 'assistant' ? 'Assistant' : 'Tool';
+        return `${role}: ${msg.content}`;
+    })
+        .join('\n\n');
+    // Create compression prompt
+    const compressionPrompt = `Please summarize the following conversation history in a concise way, preserving all important context, decisions, and key information. The summary should be detailed enough to continue the conversation seamlessly.
+
+Conversation:
+${conversationText}
+
+Summary:`;
+    try {
+        const response = await client.chat.completions.create({
+            model: config.compactModel.modelName,
+            messages: [
+                {
+                    role: 'user',
+                    content: compressionPrompt,
+                },
+            ]
+        });
+        const summary = response.choices[0]?.message?.content;
+        if (!summary) {
+            throw new Error('Failed to generate summary from compact model');
+        }
+        // Extract usage information
+        const usage = response.usage || {
+            prompt_tokens: 0,
+            completion_tokens: 0,
+            total_tokens: 0
+        };
+        return {
+            summary,
+            usage: {
+                prompt_tokens: usage.prompt_tokens,
+                completion_tokens: usage.completion_tokens,
+                total_tokens: usage.total_tokens
+            }
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Context compression failed: ${error.message}`);
+        }
+        throw new Error('Unknown error occurred during context compression');
+    }
+}

package/dist/utils/fileUtils.d.ts

@@ -33,6 +33,14 @@ export declare function createMessageWithFileInstructions(content: string, files
     platform: string;
     shell: string;
     workingDirectory: string;
+}, editorContext?: {
+    activeFile?: string;
+    selectedText?: string;
+    cursorPosition?: {
+        line: number;
+        character: number;
+    };
+    workspaceFolder?: string;
 }): string;
 /**
  * Get system information (OS, shell, working directory)

package/dist/utils/fileUtils.js

@@ -154,7 +154,7 @@ export async function parseAndValidateFileReferences(content) {
 /**
  * Create message with file read instructions for AI
  */
-export function createMessageWithFileInstructions(content, files, systemInfo) {
+export function createMessageWithFileInstructions(content, files, systemInfo, editorContext) {
     const parts = [content];
     // Add system info if provided
     if (systemInfo) {
@@ -165,6 +165,25 @@ export function createMessageWithFileInstructions(content, files, systemInfo) {
         ];
         parts.push(systemInfoLines.join('\n'));
     }
+    // Add editor context if provided (from VSCode connection)
+    if (editorContext) {
+        const editorLines = [];
+        if (editorContext.workspaceFolder) {
+            editorLines.push(`└─ VSCode Workspace: ${editorContext.workspaceFolder}`);
+        }
+        if (editorContext.activeFile) {
+            editorLines.push(`└─ Active File: ${editorContext.activeFile}`);
+        }
+        if (editorContext.cursorPosition) {
+            editorLines.push(`└─ Cursor: Line ${editorContext.cursorPosition.line + 1}, Column ${editorContext.cursorPosition.character + 1}`);
+        }
+        if (editorContext.selectedText) {
+            editorLines.push(`└─ Selected Code:\n\`\`\`\n${editorContext.selectedText}\n\`\`\``);
+        }
+        if (editorLines.length > 0) {
+            parts.push(editorLines.join('\n'));
+        }
+    }
     // Add file instructions if provided
     if (files.length > 0) {
         const fileInstructions = files

package/dist/utils/vscodeConnection.d.ts

@@ -0,0 +1,41 @@
+interface EditorContext {
+    activeFile?: string;
+    selectedText?: string;
+    cursorPosition?: {
+        line: number;
+        character: number;
+    };
+    workspaceFolder?: string;
+}
+interface Diagnostic {
+    message: string;
+    severity: 'error' | 'warning' | 'info' | 'hint';
+    line: number;
+    character: number;
+    source?: string;
+    code?: string | number;
+}
+declare class VSCodeConnectionManager {
+    private server;
+    private client;
+    private port;
+    private editorContext;
+    private listeners;
+    start(): Promise<void>;
+    stop(): void;
+    isConnected(): boolean;
+    isServerRunning(): boolean;
+    getContext(): EditorContext;
+    onContextUpdate(listener: (context: EditorContext) => void): () => void;
+    private handleMessage;
+    private notifyListeners;
+    getPort(): number;
+    /**
+     * Request diagnostics for a specific file from VS Code
+     * @param filePath - The file path to get diagnostics for
+     * @returns Promise that resolves with diagnostics array
+     */
+    requestDiagnostics(filePath: string): Promise<Diagnostic[]>;
+}
+export declare const vscodeConnection: VSCodeConnectionManager;
+export type { EditorContext, Diagnostic };

package/dist/utils/vscodeConnection.js

@@ -0,0 +1,155 @@
+import { WebSocketServer, WebSocket } from 'ws';
+class VSCodeConnectionManager {
+    constructor() {
+        Object.defineProperty(this, "server", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "port", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 9527
+        });
+        Object.defineProperty(this, "editorContext", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "listeners", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+    }
+    async start() {
+        // If already running, just return success
+        if (this.server) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                this.server = new WebSocketServer({ port: this.port });
+                this.server.on('connection', (ws) => {
+                    this.client = ws;
+                    ws.on('message', (message) => {
+                        try {
+                            const data = JSON.parse(message.toString());
+                            this.handleMessage(data);
+                        }
+                        catch (error) {
+                            // Ignore invalid JSON
+                        }
+                    });
+                    ws.on('close', () => {
+                        this.client = null;
+                    });
+                });
+                this.server.on('listening', () => {
+                    resolve();
+                });
+                this.server.on('error', (error) => {
+                    reject(error);
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    stop() {
+        if (this.client) {
+            this.client.close();
+            this.client = null;
+        }
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+    }
+    isConnected() {
+        return this.client !== null && this.client.readyState === WebSocket.OPEN;
+    }
+    isServerRunning() {
+        return this.server !== null;
+    }
+    getContext() {
+        return { ...this.editorContext };
+    }
+    onContextUpdate(listener) {
+        this.listeners.push(listener);
+        return () => {
+            this.listeners = this.listeners.filter((l) => l !== listener);
+        };
+    }
+    handleMessage(data) {
+        if (data.type === 'context') {
+            this.editorContext = {
+                activeFile: data.activeFile,
+                selectedText: data.selectedText,
+                cursorPosition: data.cursorPosition,
+                workspaceFolder: data.workspaceFolder
+            };
+            this.notifyListeners();
+        }
+    }
+    notifyListeners() {
+        for (const listener of this.listeners) {
+            listener(this.editorContext);
+        }
+    }
+    getPort() {
+        return this.port;
+    }
+    /**
+     * Request diagnostics for a specific file from VS Code
+     * @param filePath - The file path to get diagnostics for
+     * @returns Promise that resolves with diagnostics array
+     */
+    async requestDiagnostics(filePath) {
+        return new Promise((resolve) => {
+            if (!this.client || this.client.readyState !== WebSocket.OPEN) {
+                resolve([]); // Return empty array if not connected
+                return;
+            }
+            const requestId = Math.random().toString(36).substring(7);
+            const timeout = setTimeout(() => {
+                cleanup();
+                resolve([]); // Timeout, return empty array
+            }, 5000); // 5 second timeout
+            const handler = (message) => {
+                try {
+                    const data = JSON.parse(message.toString());
+                    if (data.type === 'diagnostics' && data.requestId === requestId) {
+                        cleanup();
+                        resolve(data.diagnostics || []);
+                    }
+                }
+                catch (error) {
+                    // Ignore invalid JSON
+                }
+            };
+            const cleanup = () => {
+                clearTimeout(timeout);
+                this.client?.removeListener('message', handler);
+            };
+            this.client.on('message', handler);
+            this.client.send(JSON.stringify({
+                type: 'getDiagnostics',
+                requestId,
+                filePath
+            }));
+        });
+    }
+}
+export const vscodeConnection = new VSCodeConnectionManager();

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.2.2",
+	"version": "0.2.4",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {
@@ -56,13 +56,15 @@
 		"openai": "^6.1.0",
 		"react": "^18.2.0",
 		"string-width": "^7.2.0",
-		"tiktoken": "^1.0.22"
+		"tiktoken": "^1.0.22",
+		"ws": "^8.14.2"
 	},
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "^3.0.1",
 		"@types/diff": "^7.0.2",
 		"@types/figlet": "^1.7.0",
 		"@types/react": "^18.0.32",
+		"@types/ws": "^8.5.8",
 		"@vdemedes/prettier-config": "^2.0.1",
 		"ava": "^5.2.0",
 		"chalk": "^5.2.0",