snow-ai 0.2.3 → 0.2.5

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/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();
@@ -251,6 +253,24 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
             // For any other key in history menu, just return to prevent interference
             return;
         }
+        // Ctrl+L - Delete from cursor to beginning
+        if (key.ctrl && input === 'l') {
+            const fullText = buffer.getFullText();
+            const cursorPos = buffer.getCursorPosition();
+            const afterCursor = fullText.slice(cursorPos);
+            buffer.setText(afterCursor);
+            forceStateUpdate();
+            return;
+        }
+        // Ctrl+R - Delete from cursor to end
+        if (key.ctrl && input === 'r') {
+            const fullText = buffer.getFullText();
+            const cursorPos = buffer.getCursorPosition();
+            const beforeCursor = fullText.slice(0, cursorPos);
+            buffer.setText(beforeCursor);
+            forceStateUpdate();
+            return;
+        }
         // Alt+V / Option+V - Paste from clipboard (including images)
         if (key.meta && input === 'v') {
             try {
@@ -588,5 +608,5 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
                     ? "Type to filter commands"
                     : showFilePicker
                         ? "Type to filter files • Tab/Enter to select • ESC to cancel"
-                        : "Press Ctrl+C twice to exit • Alt+V to paste images • Type '@' for files • Type '/' for commands"))))));
+                        : "Ctrl+L: delete to start • Ctrl+R: delete to end • Alt+V: paste images • '@': files • '/': commands"))))));
 }

package/dist/ui/components/CommandPanel.d.ts

@@ -8,6 +8,7 @@ interface Props {
     selectedIndex: number;
     query: string;
     visible: boolean;
+    maxHeight?: number;
 }
-declare const CommandPanel: React.MemoExoticComponent<({ commands, selectedIndex, query, visible }: Props) => React.JSX.Element | null>;
+declare const CommandPanel: React.MemoExoticComponent<({ commands, selectedIndex, visible, maxHeight }: Props) => React.JSX.Element | null>;
 export default CommandPanel;

package/dist/ui/components/CommandPanel.js

@@ -1,6 +1,31 @@
-import React, { memo } from 'react';
+import React, { memo, useMemo } from 'react';
 import { Box, Text } from 'ink';
-const CommandPanel = memo(({ commands, selectedIndex, query, visible }) => {
+const CommandPanel = memo(({ commands, selectedIndex, visible, maxHeight }) => {
+    // Fixed maximum display items to prevent rendering issues
+    const MAX_DISPLAY_ITEMS = 5;
+    const effectiveMaxItems = maxHeight ? Math.min(maxHeight, MAX_DISPLAY_ITEMS) : MAX_DISPLAY_ITEMS;
+    // Limit displayed commands
+    const displayedCommands = useMemo(() => {
+        if (commands.length <= effectiveMaxItems) {
+            return commands;
+        }
+        // Show commands around the selected index
+        const halfWindow = Math.floor(effectiveMaxItems / 2);
+        let startIndex = Math.max(0, selectedIndex - halfWindow);
+        let endIndex = Math.min(commands.length, startIndex + effectiveMaxItems);
+        // Adjust if we're near the end
+        if (endIndex - startIndex < effectiveMaxItems) {
+            startIndex = Math.max(0, endIndex - effectiveMaxItems);
+        }
+        return commands.slice(startIndex, endIndex);
+    }, [commands, selectedIndex, effectiveMaxItems]);
+    // Calculate actual selected index in the displayed subset
+    const displayedSelectedIndex = useMemo(() => {
+        return displayedCommands.findIndex((cmd) => {
+            const originalIndex = commands.indexOf(cmd);
+            return originalIndex === selectedIndex;
+        });
+    }, [displayedCommands, commands, selectedIndex]);
     // Don't show panel if not visible or no commands found
     if (!visible || commands.length === 0) {
         return null;
@@ -11,16 +36,21 @@ const CommandPanel = memo(({ commands, selectedIndex, query, visible }) => {
                 React.createElement(Box, null,
                     React.createElement(Text, { color: "yellow", bold: true },
                         "Available Commands ",
-                        query && `(${commands.length} matches)`)),
-                commands.map((command, index) => (React.createElement(Box, { key: command.name, flexDirection: "column", width: "100%" },
-                    React.createElement(Text, { color: index === selectedIndex ? "green" : "gray", bold: true },
-                        index === selectedIndex ? "➣ " : "  ",
+                        commands.length > effectiveMaxItems && `(${selectedIndex + 1}/${commands.length})`)),
+                displayedCommands.map((command, index) => (React.createElement(Box, { key: command.name, flexDirection: "column", width: "100%" },
+                    React.createElement(Text, { color: index === displayedSelectedIndex ? "green" : "gray", bold: true },
+                        index === displayedSelectedIndex ? "➣ " : "  ",
                         "/",
                         command.name),
                     React.createElement(Box, { marginLeft: 3 },
-                        React.createElement(Text, { color: index === selectedIndex ? "green" : "gray", dimColor: true },
+                        React.createElement(Text, { color: index === displayedSelectedIndex ? "green" : "gray", dimColor: true },
                             "\u2514\u2500 ",
-                            command.description)))))))));
+                            command.description))))),
+                commands.length > effectiveMaxItems && (React.createElement(Box, { marginTop: 1 },
+                    React.createElement(Text, { color: "gray", dimColor: true },
+                        "\u2191\u2193 to scroll \u00B7 ",
+                        commands.length - effectiveMaxItems,
+                        " more hidden")))))));
 });
 CommandPanel.displayName = 'CommandPanel';
 export default CommandPanel;

package/dist/ui/components/FileList.js

@@ -5,6 +5,11 @@ import path from 'path';
 const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10, rootPath = process.cwd(), onFilteredCountChange }, ref) => {
     const [files, setFiles] = useState([]);
     const [isLoading, setIsLoading] = useState(false);
+    // Fixed maximum display items to prevent rendering issues
+    const MAX_DISPLAY_ITEMS = 5;
+    const effectiveMaxItems = useMemo(() => {
+        return maxItems ? Math.min(maxItems, MAX_DISPLAY_ITEMS) : MAX_DISPLAY_ITEMS;
+    }, [maxItems]);
     // Get files from directory - optimized to batch updates
     const loadFiles = useCallback(async () => {
         const getFilesRecursively = async (dir, depth = 0, maxDepth = 3) => {
@@ -60,48 +65,59 @@ const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10
             loadFiles();
         }
     }, [visible, loadFiles]);
-    // Filter files based on query
-    const filteredFiles = useMemo(() => {
-        let filtered;
+    // Filter files based on query (no limit here, we'll slice for display)
+    const allFilteredFiles = useMemo(() => {
         if (!query.trim()) {
-            filtered = files.slice(0, maxItems);
-        }
-        else {
-            const queryLower = query.toLowerCase();
-            filtered = files.filter(file => {
-                const fileName = file.name.toLowerCase();
-                const filePath = file.path.toLowerCase();
-                return fileName.includes(queryLower) || filePath.includes(queryLower);
-            });
-            // Sort by relevance (exact name matches first, then path matches)
-            filtered.sort((a, b) => {
-                const aNameMatch = a.name.toLowerCase().startsWith(queryLower);
-                const bNameMatch = b.name.toLowerCase().startsWith(queryLower);
-                if (aNameMatch && !bNameMatch)
-                    return -1;
-                if (!aNameMatch && bNameMatch)
-                    return 1;
-                return a.name.localeCompare(b.name);
-            });
-            filtered = filtered.slice(0, maxItems);
+            return files;
         }
+        const queryLower = query.toLowerCase();
+        const filtered = files.filter(file => {
+            const fileName = file.name.toLowerCase();
+            const filePath = file.path.toLowerCase();
+            return fileName.includes(queryLower) || filePath.includes(queryLower);
+        });
+        // Sort by relevance (exact name matches first, then path matches)
+        filtered.sort((a, b) => {
+            const aNameMatch = a.name.toLowerCase().startsWith(queryLower);
+            const bNameMatch = b.name.toLowerCase().startsWith(queryLower);
+            if (aNameMatch && !bNameMatch)
+                return -1;
+            if (!aNameMatch && bNameMatch)
+                return 1;
+            return a.name.localeCompare(b.name);
+        });
         return filtered;
-    }, [files, query, maxItems]);
+    }, [files, query]);
+    // Display with scrolling window
+    const filteredFiles = useMemo(() => {
+        if (allFilteredFiles.length <= effectiveMaxItems) {
+            return allFilteredFiles;
+        }
+        // Show files around the selected index
+        const halfWindow = Math.floor(effectiveMaxItems / 2);
+        let startIndex = Math.max(0, selectedIndex - halfWindow);
+        let endIndex = Math.min(allFilteredFiles.length, startIndex + effectiveMaxItems);
+        // Adjust if we're near the end
+        if (endIndex - startIndex < effectiveMaxItems) {
+            startIndex = Math.max(0, endIndex - effectiveMaxItems);
+        }
+        return allFilteredFiles.slice(startIndex, endIndex);
+    }, [allFilteredFiles, selectedIndex, effectiveMaxItems]);
     // Notify parent of filtered count changes
     useEffect(() => {
         if (onFilteredCountChange) {
-            onFilteredCountChange(filteredFiles.length);
+            onFilteredCountChange(allFilteredFiles.length);
         }
-    }, [filteredFiles.length, onFilteredCountChange]);
+    }, [allFilteredFiles.length, onFilteredCountChange]);
     // Expose methods to parent
     useImperativeHandle(ref, () => ({
         getSelectedFile: () => {
-            if (filteredFiles.length > 0 && selectedIndex < filteredFiles.length && filteredFiles[selectedIndex]) {
-                return filteredFiles[selectedIndex].path;
+            if (allFilteredFiles.length > 0 && selectedIndex < allFilteredFiles.length && allFilteredFiles[selectedIndex]) {
+                return allFilteredFiles[selectedIndex].path;
             }
             return null;
         }
-    }), [filteredFiles, selectedIndex]);
+    }), [allFilteredFiles, selectedIndex]);
     if (!visible) {
         return null;
     }
@@ -113,19 +129,25 @@ const FileList = memo(forwardRef(({ query, selectedIndex, visible, maxItems = 10
         return (React.createElement(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, marginTop: 1 },
             React.createElement(Text, { color: "gray" }, "No files found")));
     }
+    // Calculate display index for the scrolling window
+    const displaySelectedIndex = useMemo(() => {
+        return filteredFiles.findIndex((file) => {
+            const originalIndex = allFilteredFiles.indexOf(file);
+            return originalIndex === selectedIndex;
+        });
+    }, [filteredFiles, allFilteredFiles, selectedIndex]);
     return (React.createElement(Box, { paddingX: 1, marginTop: 1, flexDirection: "column" },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { color: "blue", bold: true },
-                "\uD83D\uDDD0 Files (",
-                filteredFiles.length,
-                ")")),
+                "\uD83D\uDDD0 Files ",
+                allFilteredFiles.length > effectiveMaxItems && `(${selectedIndex + 1}/${allFilteredFiles.length})`)),
         filteredFiles.map((file, index) => (React.createElement(Box, { key: file.path },
-            React.createElement(Text, { backgroundColor: index === selectedIndex ? "blue" : undefined, color: index === selectedIndex ? "white" : file.isDirectory ? "cyan" : "white" }, file.path)))),
-        filteredFiles.length === maxItems && files.length > maxItems && (React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { backgroundColor: index === displaySelectedIndex ? "blue" : undefined, color: index === displaySelectedIndex ? "white" : file.isDirectory ? "cyan" : "white" }, file.path)))),
+        allFilteredFiles.length > effectiveMaxItems && (React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { color: "gray", dimColor: true },
-                "... and ",
-                files.length - maxItems,
-                " more files")))));
+                "\u2191\u2193 to scroll \u00B7 ",
+                allFilteredFiles.length - effectiveMaxItems,
+                " more hidden")))));
 }));
 FileList.displayName = 'FileList';
 export default FileList;

package/dist/ui/components/Menu.js

@@ -53,7 +53,7 @@ function Menu({ options, onSelect, onSelectionChange, maxHeight }) {
     const hasMoreBelow = scrollOffset + visibleItemCount < options.length;
     const moreAboveCount = scrollOffset;
     const moreBelowCount = options.length - (scrollOffset + visibleItemCount);
-    return (React.createElement(Box, { flexDirection: "column", width: '100%', borderStyle: 'round', borderColor: "#A9C13E", padding: 1 },
+    return (React.createElement(Box, { flexDirection: "column", width: '100%', padding: 1 },
         React.createElement(Box, { marginBottom: 1 },
             React.createElement(Text, { color: "cyan" }, "Use \u2191\u2193 keys to navigate, press Enter to select:")),
         hasMoreAbove && (React.createElement(Box, null,

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,8 +63,16 @@ 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 terminalHeight = stdout?.rows || 24;
     const workingDirectory = process.cwd();
+    // Minimum terminal height required for proper rendering
+    const MIN_TERMINAL_HEIGHT = 10;
     // Use session save hook
     const { saveMessage, clearSavedMessages, initializeFromSession } = useSessionSave();
     // Sync pendingMessages to ref for real-time access in callbacks
@@ -105,6 +117,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 +206,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 +374,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,
@@ -351,6 +484,21 @@ export default function ChatScreen({}) {
     if (showMcpInfo) {
         return (React.createElement(MCPInfoScreen, { onClose: () => setShowMcpInfo(false), panelKey: mcpPanelKey }));
     }
+    // Show warning if terminal is too small
+    if (terminalHeight < MIN_TERMINAL_HEIGHT) {
+        return (React.createElement(Box, { flexDirection: "column", padding: 2 },
+            React.createElement(Box, { borderStyle: "round", borderColor: "red", padding: 1 },
+                React.createElement(Text, { color: "red", bold: true }, "\u26A0  Terminal Too Small")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "yellow" },
+                    "Your terminal height is ",
+                    terminalHeight,
+                    " lines, but at least ",
+                    MIN_TERMINAL_HEIGHT,
+                    " lines are required.")),
+            React.createElement(Box, { marginTop: 1 },
+                React.createElement(Text, { color: "gray", dimColor: true }, "Please resize your terminal window to continue."))));
+    }
     return (React.createElement(Box, { flexDirection: "column" },
         React.createElement(Static, { key: remountKey, items: [
                 React.createElement(Box, { key: "header", marginX: 1, borderColor: 'cyan', borderStyle: "round", paddingX: 2, paddingY: 1 },
@@ -469,8 +617,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/ui/pages/WelcomeScreen.js

@@ -46,9 +46,8 @@ export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
                 React.createElement(Text, { color: "gray", dimColor: true }, "Intelligent Command Line Assistant"),
                 React.createElement(Text, { color: "magenta", dimColor: true },
                     "Version ",
-                    version))),
-        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))));
+                    version),
+                onMenuSelect && (React.createElement(Box, null,
+                    React.createElement(Menu, { options: menuOptions, onSelect: onMenuSelect, onSelectionChange: handleSelectionChange }))),
+                React.createElement(Alert, { variant: 'info' }, infoText)))));
 }

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.3",
+	"version": "0.2.5",
 	"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",