snow-ai 0.1.12

package/dist/ui/components/MessageList.js

@@ -0,0 +1,16 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export default function MessageList({ messages, animationFrame, maxMessages = 6 }) {
+    if (messages.length === 0) {
+        return null;
+    }
+    return (React.createElement(Box, { marginBottom: 1, flexDirection: "column", paddingX: 1, paddingY: 1 }, messages.slice(-maxMessages).map((message, index) => (React.createElement(Box, { key: index, marginLeft: 1 },
+        React.createElement(Text, { color: message.role === 'user' ? 'blue' :
+                message.role === 'command' ? 'gray' :
+                    message.streaming ? ['#FF6EBF', 'green', 'blue', 'cyan', '#B588F8'][animationFrame] : 'cyan', bold: true }, message.role === 'user' ? '⛇' : message.role === 'command' ? '⌘' : '❆'),
+        React.createElement(Box, { marginLeft: 1, marginBottom: 1, flexDirection: "column" }, message.role === 'command' ? (React.createElement(Text, { color: "gray" },
+            "\u2514\u2500 ",
+            message.commandName)) : (React.createElement(React.Fragment, null,
+            React.createElement(Text, { color: message.role === 'user' ? 'gray' : '' }, message.content),
+            message.discontinued && (React.createElement(Text, { color: "red", bold: true }, "\u2514\u2500 user discontinue"))))))))));
+}

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

@@ -0,0 +1,6 @@
+import React from 'react';
+interface Props {
+    pendingMessages: string[];
+}
+export default function PendingMessages({ pendingMessages }: Props): React.JSX.Element | null;
+export {};

package/dist/ui/components/PendingMessages.js

@@ -0,0 +1,19 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export default function PendingMessages({ pendingMessages }) {
+    if (pendingMessages.length === 0) {
+        return null;
+    }
+    return (React.createElement(Box, { marginBottom: 1, flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1 },
+        React.createElement(Text, { color: "yellow", bold: true },
+            "\u2B11 Pending Messages (",
+            pendingMessages.length,
+            ")"),
+        pendingMessages.map((message, index) => (React.createElement(Box, { key: index, marginLeft: 1, marginY: 0 },
+            React.createElement(Text, { color: "blue", bold: true },
+                index + 1,
+                "."),
+            React.createElement(Box, { marginLeft: 1 },
+                React.createElement(Text, { color: "gray" }, message.length > 60 ? `${message.substring(0, 60)}...` : message))))),
+        React.createElement(Text, { color: "yellow", dimColor: true }, "Will be sent when AI finishes responding")));
+}

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

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

package/dist/ui/pages/ApiConfigScreen.js

@@ -0,0 +1,126 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import Gradient from 'ink-gradient';
+import { Select, Alert } from '@inkjs/ui';
+import TextInput from 'ink-text-input';
+import { getOpenAiConfig, updateOpenAiConfig, validateApiConfig, } from '../../utils/apiConfig.js';
+export default function ApiConfigScreen({ onBack, onSave }) {
+    const [baseUrl, setBaseUrl] = useState('');
+    const [apiKey, setApiKey] = useState('');
+    const [requestMethod, setRequestMethod] = useState('chat');
+    const [currentField, setCurrentField] = useState('baseUrl');
+    const [errors, setErrors] = useState([]);
+    const [isEditing, setIsEditing] = useState(false);
+    const requestMethodOptions = [
+        {
+            label: 'Chat Completions - Modern chat API (GPT-4, GPT-3.5-turbo)',
+            value: 'chat',
+        },
+        {
+            label: 'Responses - New responses API (2025, with built-in tools)',
+            value: 'responses',
+        },
+    ];
+    useEffect(() => {
+        const config = getOpenAiConfig();
+        setBaseUrl(config.baseUrl);
+        setApiKey(config.apiKey);
+        setRequestMethod(config.requestMethod || 'chat');
+    }, []);
+    useInput((input, key) => {
+        // Don't handle input when Select component is active
+        if (isEditing && currentField === 'requestMethod') {
+            return;
+        }
+        // Handle save/exit globally
+        if (input === 's' && (key.ctrl || key.meta)) {
+            const validationErrors = validateApiConfig({ baseUrl, apiKey, requestMethod });
+            if (validationErrors.length === 0) {
+                updateOpenAiConfig({ baseUrl, apiKey, requestMethod });
+                setErrors([]);
+                onSave();
+            }
+            else {
+                setErrors(validationErrors);
+            }
+        }
+        else if (key.escape) {
+            const validationErrors = validateApiConfig({ baseUrl, apiKey, requestMethod });
+            if (validationErrors.length === 0) {
+                updateOpenAiConfig({ baseUrl, apiKey, requestMethod });
+                setErrors([]);
+            }
+            onBack();
+        }
+        else if (key.return) {
+            if (isEditing) {
+                // Exit edit mode, return to navigation
+                setIsEditing(false);
+            }
+            else {
+                // Enter edit mode for current field
+                setIsEditing(true);
+            }
+        }
+        else if (!isEditing && key.upArrow) {
+            if (currentField === 'apiKey') {
+                setCurrentField('baseUrl');
+            }
+            else if (currentField === 'requestMethod') {
+                setCurrentField('apiKey');
+            }
+        }
+        else if (!isEditing && key.downArrow) {
+            if (currentField === 'baseUrl') {
+                setCurrentField('apiKey');
+            }
+            else if (currentField === 'apiKey') {
+                setCurrentField('requestMethod');
+            }
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 2, borderStyle: "double", borderColor: "cyan", paddingX: 2, paddingY: 1 },
+            React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Gradient, { name: "rainbow" }, "OpenAI API Configuration"),
+                React.createElement(Text, { color: "gray", dimColor: true }, "Configure your OpenAI API settings"))),
+        React.createElement(Box, { flexDirection: "column", marginBottom: 2 },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: currentField === 'baseUrl' ? 'green' : 'white' },
+                        currentField === 'baseUrl' ? '➣ ' : '  ',
+                        "Base URL:"),
+                    currentField === 'baseUrl' && isEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(TextInput, { value: baseUrl, onChange: setBaseUrl, placeholder: "https://api.openai.com/v1" }))),
+                    (!isEditing || currentField !== 'baseUrl') && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, baseUrl || 'Not set'))))),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: currentField === 'apiKey' ? 'green' : 'white' },
+                        currentField === 'apiKey' ? '➣ ' : '  ',
+                        "API Key:"),
+                    currentField === 'apiKey' && isEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(TextInput, { value: apiKey, onChange: setApiKey, placeholder: "sk-...", mask: "*" }))),
+                    (!isEditing || currentField !== 'apiKey') && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, apiKey ? '*'.repeat(Math.min(apiKey.length, 20)) : 'Not set'))))),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: currentField === 'requestMethod' ? 'green' : 'white' },
+                        currentField === 'requestMethod' ? '➣ ' : '  ',
+                        "Request Method:"),
+                    currentField === 'requestMethod' && isEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Select, { options: requestMethodOptions, defaultValue: requestMethod, onChange: (value) => {
+                                setRequestMethod(value);
+                                setIsEditing(false); // Auto exit edit mode after selection
+                            } }))),
+                    (!isEditing || currentField !== 'requestMethod') && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, requestMethodOptions.find(opt => opt.value === requestMethod)?.label || 'Not set')))))),
+        errors.length > 0 && (React.createElement(Box, { flexDirection: "column", marginBottom: 2 },
+            React.createElement(Text, { color: "red", bold: true }, "Errors:"),
+            errors.map((error, index) => (React.createElement(Text, { key: index, color: "red" },
+                "\u2022 ",
+                error))))),
+        React.createElement(Box, { flexDirection: "column" }, isEditing ? (React.createElement(React.Fragment, null,
+            React.createElement(Alert, { variant: "info" }, "Editing mode: Press Enter to save and exit editing (Make your changes and press Enter when done)"))) : (React.createElement(React.Fragment, null,
+            React.createElement(Alert, { variant: "info" }, "Use \u2191\u2193 to navigate between fields, press Enter to edit, and press Ctrl+S or Esc to save and return"))))));
+}

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

@@ -0,0 +1,5 @@
+import React from 'react';
+import '../../utils/commands/clear.js';
+type Props = {};
+export default function ChatScreen({}: Props): React.JSX.Element;
+export {};

package/dist/ui/pages/ChatScreen.js

@@ -0,0 +1,287 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import Gradient from 'ink-gradient';
+import ChatInput from '../components/ChatInput.js';
+import MessageList from '../components/MessageList.js';
+import PendingMessages from '../components/PendingMessages.js';
+import { createStreamingChatCompletion } from '../../api/chat.js';
+import { getOpenAiConfig } from '../../utils/apiConfig.js';
+// Import clear command to register it
+import '../../utils/commands/clear.js';
+export default function ChatScreen({}) {
+    const [messages, setMessages] = useState([]);
+    const [isStreaming, setIsStreaming] = useState(false);
+    const [animationFrame, setAnimationFrame] = useState(0);
+    const [abortController, setAbortController] = useState(null);
+    const [pendingMessages, setPendingMessages] = useState([]);
+    // Animation for streaming indicator
+    useEffect(() => {
+        if (!isStreaming)
+            return;
+        const interval = setInterval(() => {
+            setAnimationFrame(prev => (prev + 1) % 5);
+        }, 300);
+        return () => clearInterval(interval);
+    }, [isStreaming]);
+    // Auto-send pending messages when streaming stops
+    useEffect(() => {
+        if (!isStreaming && pendingMessages.length > 0) {
+            // Use setTimeout to ensure state updates are complete
+            const timer = setTimeout(() => {
+                processPendingMessages();
+            }, 100);
+            return () => clearTimeout(timer);
+        }
+        return undefined;
+    }, [isStreaming, pendingMessages.length]);
+    // ESC key handler to interrupt streaming
+    useInput((_, key) => {
+        if (key.escape && isStreaming && abortController) {
+            abortController.abort();
+            setMessages(prev => {
+                const newMessages = [...prev];
+                const lastMessage = newMessages[newMessages.length - 1];
+                if (lastMessage && lastMessage.streaming) {
+                    lastMessage.streaming = false;
+                    lastMessage.discontinued = true;
+                }
+                return newMessages;
+            });
+            // Reset streaming state, useEffect will handle pending messages
+            setIsStreaming(false);
+            setAbortController(null);
+        }
+    });
+    const handleCommandExecution = (commandName, result) => {
+        if (result.success && result.action === 'clear') {
+            // Clear all messages
+            setMessages([]);
+            // Add command execution feedback
+            const commandMessage = {
+                role: 'command',
+                content: '',
+                commandName: commandName
+            };
+            setMessages([commandMessage]);
+        }
+    };
+    const handleMessageSubmit = async (message) => {
+        // If streaming, add to pending messages instead of sending immediately
+        if (isStreaming) {
+            setPendingMessages(prev => [...prev, message]);
+            return;
+        }
+        // Process the message normally
+        await processMessage(message);
+    };
+    const processMessage = async (message) => {
+        const userMessage = { role: 'user', content: message };
+        setMessages(prev => [...prev, userMessage]);
+        setIsStreaming(true);
+        // Create new abort controller for this request
+        const controller = new AbortController();
+        setAbortController(controller);
+        const assistantMessage = { role: 'assistant', content: '', streaming: true };
+        setMessages(prev => [...prev, assistantMessage]);
+        try {
+            const config = getOpenAiConfig();
+            const model = config.advancedModel || 'gpt-4.1';
+            // Check if request method is responses (not yet implemented)
+            if (config.requestMethod === 'responses') {
+                setMessages(prev => {
+                    const newMessages = [...prev];
+                    const lastMessage = newMessages[newMessages.length - 1];
+                    if (lastMessage) {
+                        lastMessage.content = 'Responses API is not yet implemented. Please use "Chat Completions" method in API settings.';
+                        lastMessage.streaming = false;
+                    }
+                    return newMessages;
+                });
+                // Don't return here, let it fall through to finally block
+            }
+            else {
+                const chatMessages = [
+                    { role: 'system', content: 'You are a helpful coding assistant.' },
+                    ...messages.filter(msg => msg.role !== 'command').map(msg => ({ role: msg.role, content: msg.content })),
+                    { role: 'user', content: message }
+                ];
+                let fullResponse = '';
+                let currentLine = '';
+                for await (const chunk of createStreamingChatCompletion({
+                    model,
+                    messages: chatMessages,
+                    temperature: 0
+                }, controller.signal)) {
+                    if (controller.signal.aborted)
+                        break;
+                    currentLine += chunk;
+                    // Check if we have a complete line (contains newline or certain punctuation)
+                    if (chunk.includes('\n') || chunk.includes('.') || chunk.includes('!') || chunk.includes('?') || chunk.includes(';')) {
+                        fullResponse += currentLine;
+                        currentLine = '';
+                        setMessages(prev => {
+                            const newMessages = [...prev];
+                            const lastMessage = newMessages[newMessages.length - 1];
+                            if (lastMessage && lastMessage.streaming) {
+                                lastMessage.content = fullResponse;
+                            }
+                            return newMessages;
+                        });
+                    }
+                }
+                // Add any remaining content
+                if (currentLine && !controller.signal.aborted) {
+                    fullResponse += currentLine;
+                    setMessages(prev => {
+                        const newMessages = [...prev];
+                        const lastMessage = newMessages[newMessages.length - 1];
+                        if (lastMessage && lastMessage.streaming) {
+                            lastMessage.content = fullResponse;
+                        }
+                        return newMessages;
+                    });
+                }
+                setMessages(prev => {
+                    const newMessages = [...prev];
+                    const lastMessage = newMessages[newMessages.length - 1];
+                    if (lastMessage && !lastMessage.discontinued) {
+                        lastMessage.streaming = false;
+                    }
+                    return newMessages;
+                });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            setMessages(prev => {
+                const newMessages = [...prev];
+                const lastMessage = newMessages[newMessages.length - 1];
+                if (lastMessage) {
+                    lastMessage.content = `Error: ${errorMessage}`;
+                    lastMessage.streaming = false;
+                }
+                return newMessages;
+            });
+        }
+        finally {
+            setIsStreaming(false);
+            setAbortController(null);
+        }
+    };
+    const processPendingMessages = async () => {
+        if (pendingMessages.length === 0)
+            return;
+        // Get current pending messages and clear them immediately to prevent infinite loop
+        const messagesToProcess = [...pendingMessages];
+        setPendingMessages([]);
+        // Combine multiple pending messages into one
+        const combinedMessage = messagesToProcess.join('\n\n');
+        // Add user message to chat
+        const userMessage = { role: 'user', content: combinedMessage };
+        setMessages(prev => [...prev, userMessage]);
+        // Start streaming response (without calling processMessage to avoid recursion)
+        setIsStreaming(true);
+        // Create new abort controller for this request
+        const controller = new AbortController();
+        setAbortController(controller);
+        const assistantMessage = { role: 'assistant', content: '', streaming: true };
+        setMessages(prev => [...prev, assistantMessage]);
+        try {
+            const config = getOpenAiConfig();
+            const model = config.advancedModel || 'gpt-4.1';
+            // Check if request method is responses (not yet implemented)
+            if (config.requestMethod === 'responses') {
+                setMessages(prev => {
+                    const newMessages = [...prev];
+                    const lastMessage = newMessages[newMessages.length - 1];
+                    if (lastMessage) {
+                        lastMessage.content = 'Responses API is not yet implemented. Please use "Chat Completions" method in API settings.';
+                        lastMessage.streaming = false;
+                    }
+                    return newMessages;
+                });
+                // Don't return here, let it fall through to finally block
+            }
+            else {
+                const chatMessages = [
+                    { role: 'system', content: 'You are a helpful coding assistant.' },
+                    ...messages.filter(msg => msg.role !== 'command').map(msg => ({ role: msg.role, content: msg.content })),
+                    { role: 'user', content: combinedMessage }
+                ];
+                let fullResponse = '';
+                let currentLine = '';
+                for await (const chunk of createStreamingChatCompletion({
+                    model,
+                    messages: chatMessages,
+                    temperature: 0
+                }, controller.signal)) {
+                    if (controller.signal.aborted)
+                        break;
+                    currentLine += chunk;
+                    // Check if we have a complete line (contains newline or certain punctuation)
+                    if (chunk.includes('\n') || chunk.includes('.') || chunk.includes('!') || chunk.includes('?') || chunk.includes(';')) {
+                        fullResponse += currentLine;
+                        currentLine = '';
+                        setMessages(prev => {
+                            const newMessages = [...prev];
+                            const lastMessage = newMessages[newMessages.length - 1];
+                            if (lastMessage && lastMessage.streaming) {
+                                lastMessage.content = fullResponse;
+                            }
+                            return newMessages;
+                        });
+                    }
+                }
+                // Add any remaining content
+                if (currentLine && !controller.signal.aborted) {
+                    fullResponse += currentLine;
+                    setMessages(prev => {
+                        const newMessages = [...prev];
+                        const lastMessage = newMessages[newMessages.length - 1];
+                        if (lastMessage && lastMessage.streaming) {
+                            lastMessage.content = fullResponse;
+                        }
+                        return newMessages;
+                    });
+                }
+                setMessages(prev => {
+                    const newMessages = [...prev];
+                    const lastMessage = newMessages[newMessages.length - 1];
+                    if (lastMessage && !lastMessage.discontinued) {
+                        lastMessage.streaming = false;
+                    }
+                    return newMessages;
+                });
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            setMessages(prev => {
+                const newMessages = [...prev];
+                const lastMessage = newMessages[newMessages.length - 1];
+                if (lastMessage) {
+                    lastMessage.content = `Error: ${errorMessage}`;
+                    lastMessage.streaming = false;
+                }
+                return newMessages;
+            });
+        }
+        finally {
+            setIsStreaming(false);
+            setAbortController(null);
+            // Note: No recursive call here, useEffect will handle next batch
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 1, borderColor: 'cyan', borderStyle: "round", paddingX: 2, paddingY: 1 },
+            React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Text, { color: "white", bold: true },
+                    React.createElement(Text, { color: "cyan" }, "\u2746 "),
+                    React.createElement(Gradient, { name: "rainbow" }, "Programming efficiency x10!")),
+                React.createElement(Text, { color: "gray", dimColor: true }, "\u2022 Ask for code explanations and debugging help"),
+                React.createElement(Text, { color: "gray", dimColor: true }, "\u2022 Press ESC during response to interrupt"))),
+        React.createElement(MessageList, { messages: messages, animationFrame: animationFrame, maxMessages: 6 }),
+        React.createElement(PendingMessages, { pendingMessages: pendingMessages }),
+        React.createElement(Box, { marginBottom: 0 },
+            React.createElement(ChatInput, { onSubmit: handleMessageSubmit, onCommand: handleCommandExecution, placeholder: "Ask me anything about coding...", disabled: false }))));
+}

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

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