snow-ai 0.2.15 → 0.2.17

package/dist/api/models.js

@@ -1,28 +1,112 @@
-import { getOpenAiConfig } from '../utils/apiConfig.js';
-export async function fetchAvailableModels() {
-    const config = getOpenAiConfig();
-    if (!config.baseUrl) {
-        throw new Error('Base URL not configured. Please configure API settings first.');
+import { getOpenAiConfig, getCustomHeaders } from '../utils/apiConfig.js';
+/**
+ * Fetch models from OpenAI-compatible API
+ */
+async function fetchOpenAIModels(baseUrl, apiKey, customHeaders) {
+    const url = `${baseUrl.replace(/\/$/, '')}/models`;
+    const headers = {
+        'Content-Type': 'application/json',
+        ...customHeaders,
+    };
+    if (apiKey) {
+        headers['Authorization'] = `Bearer ${apiKey}`;
+    }
+    const response = await fetch(url, {
+        method: 'GET',
+        headers,
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch models: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.data || [];
+}
+/**
+ * Fetch models from Gemini API
+ */
+async function fetchGeminiModels(baseUrl, apiKey) {
+    // Gemini uses API key as query parameter
+    const url = `${baseUrl.replace(/\/$/, '')}/models?key=${apiKey}`;
+    const response = await fetch(url, {
+        method: 'GET',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch models: ${response.status} ${response.statusText}`);
     }
-    const url = `${config.baseUrl.replace(/\/$/, '')}/models`;
+    const data = await response.json();
+    // Convert Gemini format to standard Model format
+    return (data.models || []).map(model => ({
+        id: model.name.replace('models/', ''), // Remove "models/" prefix
+        object: 'model',
+        created: 0,
+        owned_by: 'google',
+    }));
+}
+/**
+ * Fetch models from Anthropic API
+ */
+async function fetchAnthropicModels(baseUrl, apiKey, customHeaders) {
+    const url = `${baseUrl.replace(/\/$/, '')}/models`;
     const headers = {
         'Content-Type': 'application/json',
+        'anthropic-version': '2023-06-01',
+        ...customHeaders,
     };
-    // Add Authorization header only if API key is provided
-    if (config.apiKey) {
-        headers['Authorization'] = `Bearer ${config.apiKey}`;
+    if (apiKey) {
+        headers['x-api-key'] = apiKey;
+    }
+    const response = await fetch(url, {
+        method: 'GET',
+        headers,
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch models: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    // Convert Anthropic format to standard Model format
+    return (data.data || []).map(model => ({
+        id: model.id,
+        object: 'model',
+        created: new Date(model.created_at).getTime() / 1000, // Convert to Unix timestamp
+        owned_by: 'anthropic',
+    }));
+}
+/**
+ * Fetch available models based on configured request method
+ */
+export async function fetchAvailableModels() {
+    const config = getOpenAiConfig();
+    if (!config.baseUrl) {
+        throw new Error('Base URL not configured. Please configure API settings first.');
     }
+    const customHeaders = getCustomHeaders();
     try {
-        const response = await fetch(url, {
-            method: 'GET',
-            headers,
-        });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch models: ${response.status} ${response.statusText}`);
+        let models;
+        switch (config.requestMethod) {
+            case 'gemini':
+                if (!config.apiKey) {
+                    throw new Error('API key is required for Gemini API');
+                }
+                models = await fetchGeminiModels(config.baseUrl.replace(/\/$/, '') + '/v1beta', config.apiKey);
+                break;
+            case 'anthropic':
+                if (!config.apiKey) {
+                    throw new Error('API key is required for Anthropic API');
+                }
+                models = await fetchAnthropicModels(config.baseUrl.replace(/\/$/, '') + '/v1', config.apiKey, customHeaders);
+                break;
+            case 'chat':
+            case 'responses':
+            default:
+                // OpenAI-compatible API
+                models = await fetchOpenAIModels(config.baseUrl, config.apiKey, customHeaders);
+                break;
         }
-        const data = await response.json();
         // Sort models alphabetically by id for better UX
-        return (data.data || []).sort((a, b) => a.id.localeCompare(b.id));
+        return models.sort((a, b) => a.id.localeCompare(b.id));
     }
     catch (error) {
         if (error instanceof Error) {

package/dist/api/responses.d.ts

@@ -31,7 +31,7 @@ export interface UsageInfo {
     cached_tokens?: number;
 }
 export interface ResponseStreamChunk {
-    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'done' | 'usage';
+    type: 'content' | 'tool_calls' | 'tool_call_delta' | 'reasoning_delta' | 'reasoning_started' | 'done' | 'usage';
     content?: string;
     tool_calls?: ToolCall[];
     delta?: string;
@@ -39,17 +39,17 @@ export interface ResponseStreamChunk {
 }
 export declare function resetOpenAIClient(): void;
 /**
- * 使用 Responses API 创建响应（非流式，带自动工具调用）
+ * 使用 Responses API 创建响应（非流式,带自动工具调用）
  */
-export declare function createResponse(options: ResponseOptions): Promise<string>;
+export declare function createResponse(options: ResponseOptions, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): Promise<string>;
 /**
  * 使用 Responses API 创建流式响应（带自动工具调用）
  */
-export declare function createStreamingResponse(options: ResponseOptions, abortSignal?: AbortSignal): AsyncGenerator<ResponseStreamChunk, void, unknown>;
+export declare function createStreamingResponse(options: ResponseOptions, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): AsyncGenerator<ResponseStreamChunk, void, unknown>;
 /**
  * 使用 Responses API 创建响应（限制工具调用轮数）
  */
-export declare function createResponseWithTools(options: ResponseOptions, maxToolRounds?: number): Promise<{
+export declare function createResponseWithTools(options: ResponseOptions, maxToolRounds?: number, abortSignal?: AbortSignal, onRetry?: (error: Error, attempt: number, nextDelay: number) => void): Promise<{
     content: string;
     toolCalls: ToolCall[];
 }>;

package/dist/api/responses.js

@@ -1,7 +1,8 @@
 import OpenAI from 'openai';
-import { getOpenAiConfig, getCustomSystemPrompt } from '../utils/apiConfig.js';
+import { getOpenAiConfig, getCustomSystemPrompt, getCustomHeaders } from '../utils/apiConfig.js';
 import { executeMCPTool } from '../utils/mcpToolsManager.js';
 import { SYSTEM_PROMPT } from './systemPrompt.js';
+import { withRetry, withRetryGenerator } from '../utils/retryUtils.js';
 /**
  * 确保 schema 符合 Responses API 的要求：
  * 1. additionalProperties: false
@@ -59,9 +60,14 @@ function getOpenAIClient() {
         if (!config.apiKey || !config.baseUrl) {
             throw new Error('OpenAI API configuration is incomplete. Please configure API settings first.');
         }
+        // Get custom headers
+        const customHeaders = getCustomHeaders();
         openaiClient = new OpenAI({
             apiKey: config.apiKey,
             baseURL: config.baseUrl,
+            defaultHeaders: {
+                ...customHeaders
+            }
         });
     }
     return openaiClient;
@@ -186,9 +192,9 @@ function convertToResponseInput(messages) {
     return { input: result, systemInstructions };
 }
 /**
- * 使用 Responses API 创建响应（非流式，带自动工具调用）
+ * 使用 Responses API 创建响应（非流式,带自动工具调用）
  */
-export async function createResponse(options) {
+export async function createResponse(options, abortSignal, onRetry) {
     const client = getOpenAIClient();
     let messages = [...options.messages];
     // 提取系统提示词和转换后的消息
@@ -207,7 +213,10 @@ export async function createResponse(options) {
                 include: options.include || ['reasoning.encrypted_content'],
                 prompt_cache_key: options.prompt_cache_key,
             };
-            const response = await client.responses.create(requestPayload);
+            const response = await withRetry(() => client.responses.create(requestPayload), {
+                abortSignal,
+                onRetry
+            });
             // 提取响应 - Responses API 返回 output 数组
             const output = response.output;
             if (!output || output.length === 0) {
@@ -271,11 +280,12 @@ export async function createResponse(options) {
 /**
  * 使用 Responses API 创建流式响应（带自动工具调用）
  */
-export async function* createStreamingResponse(options, abortSignal) {
+export async function* createStreamingResponse(options, abortSignal, onRetry) {
     const client = getOpenAIClient();
     // 提取系统提示词和转换后的消息
     const { input: requestInput, systemInstructions } = convertToResponseInput(options.messages);
-    try {
+    // 使用重试包装生成器
+    yield* withRetryGenerator(async function* () {
         const requestPayload = {
             model: options.model,
             instructions: systemInstructions,
@@ -311,7 +321,10 @@ export async function* createStreamingResponse(options, abortSignal) {
                 // 新输出项添加
                 const item = chunk.item;
                 if (item?.type === 'reasoning') {
-                    // 推理摘要开始 - 忽略
+                    // 推理摘要开始 - 发送 reasoning_started 事件
+                    yield {
+                        type: 'reasoning_started'
+                    };
                     continue;
                 }
                 else if (item?.type === 'message') {
@@ -443,29 +456,15 @@ export async function* createStreamingResponse(options, abortSignal) {
         yield {
             type: 'done'
         };
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === 'AbortError') {
-            return;
-        }
-        if (error instanceof Error) {
-            // 检查是否是 API 网关不支持 Responses API
-            if (error.message.includes('Panic detected') ||
-                error.message.includes('nil pointer') ||
-                error.message.includes('404') ||
-                error.message.includes('not found')) {
-                throw new Error('Streaming response creation failed: Your API endpoint does not support the Responses API. ' +
-                    'Please switch to "Chat Completions" method in API settings, or use an OpenAI-compatible endpoint that supports Responses API (OpenAI official API, or compatible providers).');
-            }
-            throw new Error(`Streaming response creation failed: ${error.message}`);
-        }
-        throw new Error('Streaming response creation failed: Unknown error');
-    }
+    }, {
+        abortSignal,
+        onRetry
+    });
 }
 /**
  * 使用 Responses API 创建响应（限制工具调用轮数）
  */
-export async function createResponseWithTools(options, maxToolRounds = 5) {
+export async function createResponseWithTools(options, maxToolRounds = 5, abortSignal, onRetry) {
     const client = getOpenAIClient();
     let messages = [...options.messages];
     let allToolCalls = [];
@@ -485,7 +484,10 @@ export async function createResponseWithTools(options, maxToolRounds = 5) {
                 include: options.include || ['reasoning.encrypted_content'],
                 prompt_cache_key: options.prompt_cache_key,
             };
-            const response = await client.responses.create(requestPayload);
+            const response = await withRetry(() => client.responses.create(requestPayload), {
+                abortSignal,
+                onRetry
+            });
             const output = response.output;
             if (!output || output.length === 0) {
                 throw new Error('No output from AI');

package/dist/app.js

@@ -6,6 +6,7 @@ import ApiConfigScreen from './ui/pages/ApiConfigScreen.js';
 import ModelConfigScreen from './ui/pages/ModelConfigScreen.js';
 import MCPConfigScreen from './ui/pages/MCPConfigScreen.js';
 import SystemPromptConfigScreen from './ui/pages/SystemPromptConfigScreen.js';
+import CustomHeadersScreen from './ui/pages/CustomHeadersScreen.js';
 import ChatScreen from './ui/pages/ChatScreen.js';
 import { useGlobalExit } from './hooks/useGlobalExit.js';
 import { onNavigate } from './hooks/useGlobalNavigation.js';
@@ -25,7 +26,7 @@ export default function App({ version }) {
         return unsubscribe;
     }, []);
     const handleMenuSelect = (value) => {
-        if (value === 'chat' || value === 'settings' || value === 'config' || value === 'models' || value === 'mcp' || value === 'systemprompt') {
+        if (value === 'chat' || value === 'settings' || value === 'config' || value === 'models' || value === 'mcp' || value === 'systemprompt' || value === 'customheaders') {
             setCurrentView(value);
         }
         else if (value === 'exit') {
@@ -50,6 +51,8 @@ export default function App({ version }) {
                 return (React.createElement(MCPConfigScreen, { onBack: () => setCurrentView('welcome'), onSave: () => setCurrentView('welcome') }));
             case 'systemprompt':
                 return (React.createElement(SystemPromptConfigScreen, { onBack: () => setCurrentView('welcome'), onSave: () => setCurrentView('welcome') }));
+            case 'customheaders':
+                return (React.createElement(CustomHeadersScreen, { onBack: () => setCurrentView('welcome'), onSave: () => setCurrentView('welcome') }));
             default:
                 return (React.createElement(WelcomeScreen, { version: version, onMenuSelect: handleMenuSelect }));
         }

package/dist/hooks/useClipboard.d.ts

@@ -0,0 +1,4 @@
+import { TextBuffer } from '../utils/textBuffer.js';
+export declare function useClipboard(buffer: TextBuffer, updateCommandPanelState: (text: string) => void, updateFilePickerState: (text: string, cursorPos: number) => void, triggerUpdate: () => void): {
+    pasteFromClipboard: () => Promise<void>;
+};

package/dist/hooks/useClipboard.js

@@ -0,0 +1,120 @@
+import { useCallback } from 'react';
+import { execSync } from 'child_process';
+export function useClipboard(buffer, updateCommandPanelState, updateFilePickerState, triggerUpdate) {
+    const pasteFromClipboard = useCallback(async () => {
+        try {
+            // Try to read image from clipboard
+            if (process.platform === 'win32') {
+                // Windows: Use PowerShell to read image from clipboard
+                try {
+                    const psScript = `Add-Type -AssemblyName System.Windows.Forms; Add-Type -AssemblyName System.Drawing; $clipboard = [System.Windows.Forms.Clipboard]::GetImage(); if ($clipboard -ne $null) { $ms = New-Object System.IO.MemoryStream; $clipboard.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png); $bytes = $ms.ToArray(); $ms.Close(); [Convert]::ToBase64String($bytes) }`;
+                    const base64 = execSync(`powershell -Command "${psScript}"`, {
+                        encoding: 'utf-8',
+                        timeout: 5000,
+                    }).trim();
+                    if (base64 && base64.length > 100) {
+                        const dataUrl = `data:image/png;base64,${base64}`;
+                        buffer.insertImage(dataUrl, 'image/png');
+                        const text = buffer.getFullText();
+                        const cursorPos = buffer.getCursorPosition();
+                        updateCommandPanelState(text);
+                        updateFilePickerState(text, cursorPos);
+                        triggerUpdate();
+                        return;
+                    }
+                }
+                catch (imgError) {
+                    // No image in clipboard or error, fall through to text
+                }
+            }
+            else if (process.platform === 'darwin') {
+                // macOS: Use osascript to read image from clipboard
+                try {
+                    // First check if there's an image in clipboard
+                    const checkScript = `osascript -e 'try
+	set imgData to the clipboard as «class PNGf»
+	return "hasImage"
+on error
+	return "noImage"
+end try'`;
+                    const hasImage = execSync(checkScript, {
+                        encoding: 'utf-8',
+                        timeout: 2000,
+                    }).trim();
+                    if (hasImage === 'hasImage') {
+                        // Save clipboard image to temporary file and read it
+                        const tmpFile = `/tmp/snow_clipboard_${Date.now()}.png`;
+                        const saveScript = `osascript -e 'set imgData to the clipboard as «class PNGf»' -e 'set fileRef to open for access POSIX file "${tmpFile}" with write permission' -e 'write imgData to fileRef' -e 'close access fileRef'`;
+                        execSync(saveScript, {
+                            encoding: 'utf-8',
+                            timeout: 3000,
+                        });
+                        // Read the file as base64
+                        const base64 = execSync(`base64 -i "${tmpFile}"`, {
+                            encoding: 'utf-8',
+                            timeout: 2000,
+                        }).trim();
+                        // Clean up temp file
+                        try {
+                            execSync(`rm "${tmpFile}"`, { timeout: 1000 });
+                        }
+                        catch (e) {
+                            // Ignore cleanup errors
+                        }
+                        if (base64 && base64.length > 100) {
+                            const dataUrl = `data:image/png;base64,${base64}`;
+                            buffer.insertImage(dataUrl, 'image/png');
+                            const text = buffer.getFullText();
+                            const cursorPos = buffer.getCursorPosition();
+                            updateCommandPanelState(text);
+                            updateFilePickerState(text, cursorPos);
+                            triggerUpdate();
+                            return;
+                        }
+                    }
+                }
+                catch (imgError) {
+                    // No image in clipboard or error, fall through to text
+                    console.error('Failed to read image from macOS clipboard:', imgError);
+                }
+            }
+            // If no image, try to read text from clipboard
+            try {
+                let clipboardText = '';
+                if (process.platform === 'win32') {
+                    clipboardText = execSync('powershell -Command "Get-Clipboard"', {
+                        encoding: 'utf-8',
+                        timeout: 2000,
+                    }).trim();
+                }
+                else if (process.platform === 'darwin') {
+                    clipboardText = execSync('pbpaste', {
+                        encoding: 'utf-8',
+                        timeout: 2000,
+                    }).trim();
+                }
+                else {
+                    clipboardText = execSync('xclip -selection clipboard -o', {
+                        encoding: 'utf-8',
+                        timeout: 2000,
+                    }).trim();
+                }
+                if (clipboardText) {
+                    buffer.insert(clipboardText);
+                    const fullText = buffer.getFullText();
+                    const cursorPos = buffer.getCursorPosition();
+                    updateCommandPanelState(fullText);
+                    updateFilePickerState(fullText, cursorPos);
+                    triggerUpdate();
+                }
+            }
+            catch (textError) {
+                console.error('Failed to read text from clipboard:', textError);
+            }
+        }
+        catch (error) {
+            console.error('Failed to read from clipboard:', error);
+        }
+    }, [buffer, updateCommandPanelState, updateFilePickerState, triggerUpdate]);
+    return { pasteFromClipboard };
+}

package/dist/hooks/useCommandHandler.d.ts

@@ -0,0 +1,26 @@
+import type { Message } from '../ui/components/MessageList.js';
+import type { UsageInfo } from '../api/chat.js';
+type CommandHandlerOptions = {
+    messages: Message[];
+    setMessages: React.Dispatch<React.SetStateAction<Message[]>>;
+    setRemountKey: React.Dispatch<React.SetStateAction<number>>;
+    clearSavedMessages: () => void;
+    setIsCompressing: React.Dispatch<React.SetStateAction<boolean>>;
+    setCompressionError: React.Dispatch<React.SetStateAction<string | null>>;
+    setShowSessionPanel: React.Dispatch<React.SetStateAction<boolean>>;
+    setShowMcpInfo: React.Dispatch<React.SetStateAction<boolean>>;
+    setShowMcpPanel: React.Dispatch<React.SetStateAction<boolean>>;
+    setMcpPanelKey: React.Dispatch<React.SetStateAction<number>>;
+    setYoloMode: React.Dispatch<React.SetStateAction<boolean>>;
+    setContextUsage: React.Dispatch<React.SetStateAction<UsageInfo | null>>;
+    setShouldIncludeSystemInfo: React.Dispatch<React.SetStateAction<boolean>>;
+    setVscodeConnectionStatus: React.Dispatch<React.SetStateAction<'disconnected' | 'connecting' | 'connected' | 'error'>>;
+    processMessage: (message: string, images?: Array<{
+        data: string;
+        mimeType: string;
+    }>, useBasicModel?: boolean, hideUserMessage?: boolean) => Promise<void>;
+};
+export declare function useCommandHandler(options: CommandHandlerOptions): {
+    handleCommandExecution: (commandName: string, result: any) => Promise<void>;
+};
+export {};

package/dist/hooks/useCommandHandler.js

@@ -0,0 +1,158 @@
+import { useStdout } from 'ink';
+import { useCallback } from 'react';
+import { sessionManager } from '../utils/sessionManager.js';
+import { compressContext } from '../utils/contextCompressor.js';
+import { navigateTo } from './useGlobalNavigation.js';
+export function useCommandHandler(options) {
+    const { stdout } = useStdout();
+    const handleCommandExecution = useCallback(async (commandName, result) => {
+        // Handle /compact command
+        if (commandName === 'compact' &&
+            result.success &&
+            result.action === 'compact') {
+            // Set compressing state (不添加命令面板消息)
+            options.setIsCompressing(true);
+            options.setCompressionError(null);
+            try {
+                // Convert messages to ChatMessage format for compression
+                const chatMessages = options.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();
+                options.clearSavedMessages();
+                options.setMessages([summaryMessage]);
+                options.setRemountKey(prev => prev + 1);
+                // Reset system info flag to include in next message
+                options.setShouldIncludeSystemInfo(true);
+                // Update token usage with compression result
+                options.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';
+                options.setCompressionError(errorMsg);
+                const errorMessage = {
+                    role: 'assistant',
+                    content: `**Compression Failed**\n\n${errorMsg}`,
+                    streaming: false,
+                };
+                options.setMessages(prev => [...prev, errorMessage]);
+            }
+            finally {
+                options.setIsCompressing(false);
+            }
+            return;
+        }
+        // Handle /ide command
+        if (commandName === 'ide') {
+            if (result.success) {
+                options.setVscodeConnectionStatus('connecting');
+                // Add command execution feedback
+                const commandMessage = {
+                    role: 'command',
+                    content: '',
+                    commandName: commandName,
+                };
+                options.setMessages(prev => [...prev, commandMessage]);
+            }
+            else {
+                options.setVscodeConnectionStatus('error');
+            }
+            return;
+        }
+        if (result.success && result.action === 'clear') {
+            if (stdout && typeof stdout.write === 'function') {
+                stdout.write('\x1B[3J\x1B[2J\x1B[H');
+            }
+            // Clear current session and start new one
+            sessionManager.clearCurrentSession();
+            options.clearSavedMessages();
+            options.setMessages([]);
+            options.setRemountKey(prev => prev + 1);
+            // Reset context usage (token statistics)
+            options.setContextUsage(null);
+            // Reset system info flag to include in next message
+            options.setShouldIncludeSystemInfo(true);
+            // Note: yoloMode is preserved via localStorage (lines 68-76, 104-111)
+            // Note: VSCode connection is preserved and managed by vscodeConnection utility
+            // Add command execution feedback
+            const commandMessage = {
+                role: 'command',
+                content: '',
+                commandName: commandName,
+            };
+            options.setMessages([commandMessage]);
+        }
+        else if (result.success && result.action === 'showSessionPanel') {
+            options.setShowSessionPanel(true);
+            const commandMessage = {
+                role: 'command',
+                content: '',
+                commandName: commandName,
+            };
+            options.setMessages(prev => [...prev, commandMessage]);
+        }
+        else if (result.success && result.action === 'showMcpInfo') {
+            options.setShowMcpInfo(true);
+            options.setMcpPanelKey(prev => prev + 1);
+            const commandMessage = {
+                role: 'command',
+                content: '',
+                commandName: commandName,
+            };
+            options.setMessages(prev => [...prev, commandMessage]);
+        }
+        else if (result.success && result.action === 'showMcpPanel') {
+            options.setShowMcpPanel(true);
+            const commandMessage = {
+                role: 'command',
+                content: '',
+                commandName: commandName,
+            };
+            options.setMessages(prev => [...prev, commandMessage]);
+        }
+        else if (result.success && result.action === 'goHome') {
+            navigateTo('welcome');
+        }
+        else if (result.success && result.action === 'toggleYolo') {
+            options.setYoloMode(prev => !prev);
+            const commandMessage = {
+                role: 'command',
+                content: '',
+                commandName: commandName,
+            };
+            options.setMessages(prev => [...prev, commandMessage]);
+        }
+        else if (result.success &&
+            result.action === 'initProject' &&
+            result.prompt) {
+            // Add command execution feedback
+            const commandMessage = {
+                role: 'command',
+                content: '',
+                commandName: commandName,
+            };
+            options.setMessages(prev => [...prev, commandMessage]);
+            // Auto-send the prompt using basicModel, hide the prompt from UI
+            options.processMessage(result.prompt, undefined, true, true);
+        }
+    }, [stdout, options]);
+    return { handleCommandExecution };
+}

package/dist/hooks/useCommandPanel.d.ts

@@ -0,0 +1,16 @@
+import { TextBuffer } from '../utils/textBuffer.js';
+export declare function useCommandPanel(buffer: TextBuffer): {
+    showCommands: boolean;
+    setShowCommands: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    commandSelectedIndex: number;
+    setCommandSelectedIndex: import("react").Dispatch<import("react").SetStateAction<number>>;
+    getFilteredCommands: () => {
+        name: string;
+        description: string;
+    }[];
+    updateCommandPanelState: (text: string) => void;
+    commands: {
+        name: string;
+        description: string;
+    }[];
+};