snow-ai 0.1.12

package/dist/api/chat.d.ts

@@ -0,0 +1,29 @@
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+}
+export interface ChatCompletionOptions {
+    model: string;
+    messages: ChatMessage[];
+    stream?: boolean;
+    temperature?: number;
+    max_tokens?: number;
+}
+export interface ChatCompletionChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        delta: {
+            role?: string;
+            content?: string;
+        };
+        finish_reason?: string | null;
+    }>;
+}
+export declare function resetOpenAIClient(): void;
+export declare function createChatCompletion(options: ChatCompletionOptions): Promise<string>;
+export declare function createStreamingChatCompletion(options: ChatCompletionOptions, abortSignal?: AbortSignal): AsyncGenerator<string, void, unknown>;
+export declare function validateChatOptions(options: ChatCompletionOptions): string[];

package/dist/api/chat.js

@@ -0,0 +1,88 @@
+import OpenAI from 'openai';
+import { getOpenAiConfig } from '../utils/apiConfig.js';
+let openaiClient = null;
+function getOpenAIClient() {
+    if (!openaiClient) {
+        const config = getOpenAiConfig();
+        if (!config.apiKey || !config.baseUrl) {
+            throw new Error('OpenAI API configuration is incomplete. Please configure API settings first.');
+        }
+        openaiClient = new OpenAI({
+            apiKey: config.apiKey,
+            baseURL: config.baseUrl,
+        });
+    }
+    return openaiClient;
+}
+export function resetOpenAIClient() {
+    openaiClient = null;
+}
+export async function createChatCompletion(options) {
+    const client = getOpenAIClient();
+    try {
+        const response = await client.chat.completions.create({
+            model: options.model,
+            messages: options.messages,
+            stream: false,
+            temperature: options.temperature || 0.7,
+            max_tokens: options.max_tokens,
+        });
+        return response.choices[0]?.message?.content || '';
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Chat completion failed: ${error.message}`);
+        }
+        throw new Error('Chat completion failed: Unknown error');
+    }
+}
+export async function* createStreamingChatCompletion(options, abortSignal) {
+    const client = getOpenAIClient();
+    try {
+        const stream = await client.chat.completions.create({
+            model: options.model,
+            messages: options.messages,
+            stream: true,
+            temperature: options.temperature || 0.7,
+            max_tokens: options.max_tokens,
+        }, {
+            signal: abortSignal,
+        });
+        for await (const chunk of stream) {
+            if (abortSignal?.aborted) {
+                break;
+            }
+            const content = chunk.choices[0]?.delta?.content;
+            if (content) {
+                yield content;
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            return; // Silently handle abort
+        }
+        if (error instanceof Error) {
+            throw new Error(`Streaming chat completion failed: ${error.message}`);
+        }
+        throw new Error('Streaming chat completion failed: Unknown error');
+    }
+}
+export function validateChatOptions(options) {
+    const errors = [];
+    if (!options.model || options.model.trim().length === 0) {
+        errors.push('Model is required');
+    }
+    if (!options.messages || options.messages.length === 0) {
+        errors.push('At least one message is required');
+    }
+    for (const message of options.messages || []) {
+        if (!message.role || !['system', 'user', 'assistant'].includes(message.role)) {
+            errors.push('Invalid message role');
+        }
+        if (!message.content || message.content.trim().length === 0) {
+            errors.push('Message content cannot be empty');
+        }
+    }
+    return errors;
+}

package/dist/api/models.d.ts

@@ -0,0 +1,12 @@
+export interface Model {
+    id: string;
+    object: string;
+    created: number;
+    owned_by: string;
+}
+export interface ModelsResponse {
+    object: string;
+    data: Model[];
+}
+export declare function fetchAvailableModels(): Promise<Model[]>;
+export declare function filterModels(models: Model[], searchTerm: string): Model[];

package/dist/api/models.js

@@ -0,0 +1,40 @@
+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.');
+    }
+    const url = `${config.baseUrl.replace(/\/$/, '')}/models`;
+    const headers = {
+        'Content-Type': 'application/json',
+    };
+    // Add Authorization header only if API key is provided
+    if (config.apiKey) {
+        headers['Authorization'] = `Bearer ${config.apiKey}`;
+    }
+    try {
+        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();
+        // Sort models alphabetically by id for better UX
+        return (data.data || []).sort((a, b) => a.id.localeCompare(b.id));
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            throw new Error(`Error fetching models: ${error.message}`);
+        }
+        throw new Error('Unknown error occurred while fetching models');
+    }
+}
+export function filterModels(models, searchTerm) {
+    if (!searchTerm.trim()) {
+        return models;
+    }
+    const lowerSearchTerm = searchTerm.toLowerCase();
+    return models.filter(model => model.id.toLowerCase().includes(lowerSearchTerm));
+}

package/dist/app.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+type Props = {
+    version?: string;
+};
+export default function App({ version }: Props): React.JSX.Element;
+export {};

package/dist/app.js

@@ -0,0 +1,47 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import { Alert } from '@inkjs/ui';
+import WelcomeScreen from './ui/pages/WelcomeScreen.js';
+import ApiConfigScreen from './ui/pages/ApiConfigScreen.js';
+import ModelConfigScreen from './ui/pages/ModelConfigScreen.js';
+import ChatScreen from './ui/pages/ChatScreen.js';
+import { useGlobalExit } from './hooks/useGlobalExit.js';
+export default function App({ version }) {
+    const [currentView, setCurrentView] = useState('welcome');
+    const [exitNotification, setExitNotification] = useState({
+        show: false,
+        message: ''
+    });
+    // Global exit handler
+    useGlobalExit(setExitNotification);
+    const handleMenuSelect = (value) => {
+        if (value === 'chat' || value === 'settings' || value === 'config' || value === 'models') {
+            setCurrentView(value);
+        }
+        else if (value === 'exit') {
+            process.exit(0);
+        }
+    };
+    const renderView = () => {
+        switch (currentView) {
+            case 'welcome':
+                return (React.createElement(WelcomeScreen, { version: version, onMenuSelect: handleMenuSelect }));
+            case 'chat':
+                return (React.createElement(ChatScreen, null));
+            case 'settings':
+                return (React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: "blue" }, "Settings"),
+                    React.createElement(Text, { color: "gray" }, "Settings interface would be implemented here")));
+            case 'config':
+                return (React.createElement(ApiConfigScreen, { onBack: () => setCurrentView('welcome'), onSave: () => setCurrentView('welcome') }));
+            case 'models':
+                return (React.createElement(ModelConfigScreen, { onBack: () => setCurrentView('welcome'), onSave: () => setCurrentView('welcome') }));
+            default:
+                return (React.createElement(WelcomeScreen, { version: version, onMenuSelect: handleMenuSelect }));
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        renderView(),
+        exitNotification.show && (React.createElement(Box, { padding: 1 },
+            React.createElement(Alert, { variant: "warning" }, exitNotification.message)))));
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import React from 'react';
+import { render } from 'ink';
+import meow from 'meow';
+import App from './app.js';
+const cli = meow(`
+	Usage
+	  $ aibotpro
+
+	Options
+		--help     Show help
+		--version  Show version
+`, {
+    importMeta: import.meta,
+    flags: {},
+});
+render(React.createElement(App, { version: cli.pkg.version }), {
+    exitOnCtrlC: false,
+});

package/dist/constants/index.d.ts

@@ -0,0 +1,18 @@
+export declare const APP_NAME = "AI Bot CLI";
+export declare const APP_VERSION = "1.0.0";
+export declare const APP_DESCRIPTION = "Intelligent Command Line Assistant";
+export declare const COLORS: {
+    readonly primary: "cyan";
+    readonly secondary: "magenta";
+    readonly success: "green";
+    readonly warning: "yellow";
+    readonly error: "red";
+    readonly info: "blue";
+    readonly muted: "gray";
+};
+export declare const COMMANDS: {
+    readonly HELP: "help";
+    readonly VERSION: "version";
+    readonly EXIT: "exit";
+    readonly CLEAR: "clear";
+};

package/dist/constants/index.js

@@ -0,0 +1,18 @@
+export const APP_NAME = 'AI Bot CLI';
+export const APP_VERSION = '1.0.0';
+export const APP_DESCRIPTION = 'Intelligent Command Line Assistant';
+export const COLORS = {
+    primary: 'cyan',
+    secondary: 'magenta',
+    success: 'green',
+    warning: 'yellow',
+    error: 'red',
+    info: 'blue',
+    muted: 'gray',
+};
+export const COMMANDS = {
+    HELP: 'help',
+    VERSION: 'version',
+    EXIT: 'exit',
+    CLEAR: 'clear',
+};

package/dist/hooks/useGlobalExit.d.ts

@@ -0,0 +1,5 @@
+export interface ExitNotification {
+    show: boolean;
+    message: string;
+}
+export declare function useGlobalExit(onNotification?: (notification: ExitNotification) => void): void;

package/dist/hooks/useGlobalExit.js

@@ -0,0 +1,32 @@
+import { useInput } from 'ink';
+import { useState } from 'react';
+export function useGlobalExit(onNotification) {
+    const [lastCtrlCTime, setLastCtrlCTime] = useState(0);
+    const ctrlCTimeout = 1000; // 1 second timeout for double Ctrl+C
+    useInput((input, key) => {
+        if (key.ctrl && input === 'c') {
+            const now = Date.now();
+            if (now - lastCtrlCTime < ctrlCTimeout) {
+                // Second Ctrl+C within timeout - exit
+                process.exit(0);
+            }
+            else {
+                // First Ctrl+C - show notification
+                setLastCtrlCTime(now);
+                if (onNotification) {
+                    onNotification({
+                        show: true,
+                        message: 'Press Ctrl+C again to exit'
+                    });
+                    // Hide notification after timeout
+                    setTimeout(() => {
+                        onNotification({
+                            show: false,
+                            message: ''
+                        });
+                    }, ctrlCTimeout);
+                }
+            }
+        }
+    });
+}

package/dist/types/index.d.ts

@@ -0,0 +1,15 @@
+export interface AIBotConfig {
+    model?: string;
+    apiKey?: string;
+    maxTokens?: number;
+}
+export interface Command {
+    name: string;
+    description: string;
+    handler: (args: string[]) => Promise<void>;
+}
+export interface AppState {
+    isLoading: boolean;
+    currentCommand?: string;
+    history: string[];
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,9 @@
+import React from 'react';
+type Props = {
+    onSubmit: (message: string) => void;
+    onCommand?: (commandName: string, result: any) => void;
+    placeholder?: string;
+    disabled?: boolean;
+};
+export default function ChatInput({ onSubmit, onCommand, placeholder, disabled }: Props): React.JSX.Element;
+export {};

package/dist/ui/components/ChatInput.js

@@ -0,0 +1,206 @@
+import React, { useState, useEffect, useRef, useCallback } from 'react';
+import { Box, Text, useStdout, useInput } from 'ink';
+import { TextBuffer } from '../../utils/textBuffer.js';
+import { cpSlice } from '../../utils/textUtils.js';
+import CommandPanel from './CommandPanel.js';
+import { executeCommand } from '../../utils/commandExecutor.js';
+// Command Definition
+const commands = [
+    { name: 'clear', description: 'Clear chat context and conversation history' },
+    { name: 'agents', description: 'Manage agent configurations' }
+];
+export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type your message...', disabled = false }) {
+    const { stdout } = useStdout();
+    const terminalWidth = stdout?.columns || 80;
+    const uiOverhead = 8;
+    const viewport = {
+        width: Math.max(40, terminalWidth - uiOverhead),
+        height: 1
+    };
+    const [buffer] = useState(() => new TextBuffer(viewport));
+    const [, forceUpdate] = useState({});
+    const lastUpdateTime = useRef(0);
+    // Command panel state
+    const [showCommands, setShowCommands] = useState(false);
+    const [commandSelectedIndex, setCommandSelectedIndex] = useState(0);
+    // Get filtered commands based on current input
+    const getFilteredCommands = useCallback(() => {
+        const text = buffer.getFullText();
+        if (!text.startsWith('/'))
+            return [];
+        const query = text.slice(1).toLowerCase();
+        return commands.filter(command => command.name.toLowerCase().includes(query) ||
+            command.description.toLowerCase().includes(query));
+    }, [buffer]);
+    // Update command panel state
+    const updateCommandPanelState = useCallback((text) => {
+        if (text.startsWith('/') && text.length > 0) {
+            setShowCommands(true);
+            setCommandSelectedIndex(0);
+        }
+        else {
+            setShowCommands(false);
+            setCommandSelectedIndex(0);
+        }
+    }, []);
+    // Force re-render when buffer changes
+    const triggerUpdate = useCallback(() => {
+        const now = Date.now();
+        // Avoid too frequent updates
+        if (now - lastUpdateTime.current > 16) { // ~60fps limit
+            lastUpdateTime.current = now;
+            forceUpdate({});
+        }
+    }, []);
+    // Update buffer viewport when terminal width changes
+    useEffect(() => {
+        const newViewport = {
+            width: Math.max(40, terminalWidth - uiOverhead),
+            height: 1
+        };
+        buffer.updateViewport(newViewport);
+        triggerUpdate();
+    }, [terminalWidth, buffer, triggerUpdate]);
+    // Handle input using useInput hook instead of raw stdin
+    useInput((input, key) => {
+        if (disabled)
+            return;
+        // Backspace
+        if (key.backspace || key.delete) {
+            buffer.backspace();
+            const text = buffer.getFullText();
+            updateCommandPanelState(text);
+            triggerUpdate();
+            return;
+        }
+        // Handle command panel navigation
+        if (showCommands) {
+            const filteredCommands = getFilteredCommands();
+            // Up arrow in command panel
+            if (key.upArrow) {
+                setCommandSelectedIndex(prev => Math.max(0, prev - 1));
+                return;
+            }
+            // Down arrow in command panel
+            if (key.downArrow) {
+                const maxIndex = Math.max(0, filteredCommands.length - 1);
+                setCommandSelectedIndex(prev => Math.min(maxIndex, prev + 1));
+                return;
+            }
+            // Enter - select command
+            if (key.return) {
+                if (filteredCommands.length > 0 && commandSelectedIndex < filteredCommands.length) {
+                    const selectedCommand = filteredCommands[commandSelectedIndex];
+                    if (selectedCommand) {
+                        // Execute command instead of inserting text
+                        executeCommand(selectedCommand.name).then(result => {
+                            if (onCommand) {
+                                onCommand(selectedCommand.name, result);
+                            }
+                        });
+                        buffer.setText('');
+                        setShowCommands(false);
+                        setCommandSelectedIndex(0);
+                        triggerUpdate();
+                        return;
+                    }
+                }
+                // If no commands available, fall through to normal Enter handling
+            }
+        }
+        // Enter - submit message
+        if (key.return) {
+            const message = buffer.getFullText().trim();
+            if (message) {
+                buffer.setText('');
+                forceUpdate({});
+                onSubmit(message);
+            }
+            return;
+        }
+        // Arrow keys for cursor movement
+        if (key.leftArrow) {
+            buffer.moveLeft();
+            triggerUpdate();
+            return;
+        }
+        if (key.rightArrow) {
+            buffer.moveRight();
+            triggerUpdate();
+            return;
+        }
+        if (key.upArrow && !showCommands) {
+            buffer.moveUp();
+            triggerUpdate();
+            return;
+        }
+        if (key.downArrow && !showCommands) {
+            buffer.moveDown();
+            triggerUpdate();
+            return;
+        }
+        // Regular character input
+        if (input && !key.ctrl && !key.meta && !key.escape) {
+            buffer.insert(input);
+            const text = buffer.getFullText();
+            updateCommandPanelState(text);
+            triggerUpdate();
+        }
+    });
+    // Handle paste events - useInput should handle paste automatically
+    // but we may need to handle large pastes specially
+    useEffect(() => {
+        const handlePaste = (event) => {
+            if (event.clipboardData) {
+                const pastedText = event.clipboardData.getData('text');
+                if (pastedText && pastedText.length > 0) {
+                    // Let TextBuffer handle the paste processing
+                    buffer.insert(pastedText);
+                    const text = buffer.getFullText();
+                    updateCommandPanelState(text);
+                    triggerUpdate();
+                }
+            }
+        };
+        // Note: This might not work in all terminal environments
+        // but the useInput hook should handle most paste scenarios
+        if (typeof window !== 'undefined') {
+            window.addEventListener('paste', handlePaste);
+            return () => window.removeEventListener('paste', handlePaste);
+        }
+        return undefined;
+    }, [buffer, updateCommandPanelState, triggerUpdate]);
+    const visualLines = buffer.viewportVisualLines;
+    const [cursorRow, cursorCol] = buffer.visualCursor;
+    // Render content with cursor and paste placeholders
+    const renderContent = useCallback(() => {
+        if (buffer.text.length > 0) {
+            return visualLines.map((line, index) => (React.createElement(Box, { key: `line-${index}` },
+                React.createElement(Text, null, index === cursorRow ? (React.createElement(React.Fragment, null,
+                    cpSlice(line, 0, cursorCol),
+                    React.createElement(Text, { backgroundColor: "white", color: "black" }, (() => {
+                        const charInfo = buffer.getCharAtCursor();
+                        return charInfo.char === '\n' ? ' ' : charInfo.char;
+                    })()),
+                    cpSlice(line, cursorCol + 1))) : (
+                // Check for paste placeholders and highlight them
+                line.includes('[Paste ') && line.includes(' line #') ? (React.createElement(Text, null, line.split(/(\[Paste \d+ line #\d+\])/).map((part, partIndex) => part.match(/^\[Paste \d+ line #\d+\]$/) ? (React.createElement(Text, { key: partIndex, color: "cyan", dimColor: true }, part)) : (React.createElement(Text, { key: partIndex }, part))))) : (line || ' '))))));
+        }
+        else {
+            return (React.createElement(Box, null,
+                React.createElement(Text, { backgroundColor: disabled ? "gray" : "white", color: disabled ? "darkGray" : "black" }, ' '),
+                React.createElement(Text, { color: disabled ? "darkGray" : "gray", dimColor: true }, disabled ? 'Waiting for response...' : placeholder)));
+        }
+    }, [visualLines, cursorRow, cursorCol, buffer, placeholder]);
+    return (React.createElement(Box, { flexDirection: "column", width: "100%" },
+        React.createElement(Box, { flexDirection: "row", borderStyle: "round", borderColor: "gray", paddingX: 1, paddingY: 0, width: "100%" },
+            React.createElement(Text, { color: "cyan", bold: true },
+                "\u27A3",
+                ' '),
+            React.createElement(Box, { flexDirection: "column", flexGrow: 1 }, renderContent())),
+        React.createElement(CommandPanel, { commands: getFilteredCommands(), selectedIndex: commandSelectedIndex, query: buffer.getFullText().slice(1), visible: showCommands }),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "gray", dimColor: true }, showCommands && getFilteredCommands().length > 0
+                ? "Type to filter commands"
+                : "Press Ctrl+C twice to exit"))));
+}

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

@@ -0,0 +1,13 @@
+import React from 'react';
+interface Command {
+    name: string;
+    description: string;
+}
+interface Props {
+    commands: Command[];
+    selectedIndex: number;
+    query: string;
+    visible: boolean;
+}
+export default function CommandPanel({ commands, selectedIndex, query, visible }: Props): React.JSX.Element | null;
+export {};

package/dist/ui/components/CommandPanel.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+export default function CommandPanel({ commands, selectedIndex, query, visible }) {
+    // Don't show panel if not visible or no commands found
+    if (!visible || commands.length === 0) {
+        return null;
+    }
+    return (React.createElement(Box, { flexDirection: "column" },
+        React.createElement(Box, { width: "100%" },
+            React.createElement(Box, { flexDirection: "column", width: "100%" },
+                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: "row", width: "100%" },
+                    React.createElement(Text, { color: index === selectedIndex ? "green" : "gray" },
+                        index === selectedIndex ? "➣ " : "  ",
+                        "/",
+                        command.name),
+                    React.createElement(Box, { marginLeft: 2 },
+                        React.createElement(Text, { color: index === selectedIndex ? "green" : "gray", dimColor: true }, command.description)))))))));
+}

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

@@ -0,0 +1,14 @@
+import React from 'react';
+type MenuOption = {
+    label: string;
+    value: string;
+    color?: string;
+    infoText?: string;
+};
+type Props = {
+    options: MenuOption[];
+    onSelect: (value: string) => void;
+    onSelectionChange?: (infoText: string) => void;
+};
+export default function Menu({ options, onSelect, onSelectionChange }: Props): React.JSX.Element;
+export {};

package/dist/ui/components/Menu.js

@@ -0,0 +1,32 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export default function Menu({ options, onSelect, onSelectionChange }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    React.useEffect(() => {
+        const currentOption = options[selectedIndex];
+        if (onSelectionChange && currentOption?.infoText) {
+            onSelectionChange(currentOption.infoText);
+        }
+    }, [selectedIndex, options, onSelectionChange]);
+    useInput((_, key) => {
+        if (key.upArrow) {
+            setSelectedIndex(prev => (prev > 0 ? prev - 1 : options.length - 1));
+        }
+        else if (key.downArrow) {
+            setSelectedIndex(prev => (prev < options.length - 1 ? prev + 1 : 0));
+        }
+        else if (key.return) {
+            const selectedOption = options[selectedIndex];
+            if (selectedOption) {
+                onSelect(selectedOption.value);
+            }
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column", width: '100%', borderStyle: 'round', borderColor: "#A9C13E", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "cyan" }, "Use \u2191\u2193 keys to navigate, press Enter to select:")),
+        options.map((option, index) => (React.createElement(Box, { key: option.value },
+            React.createElement(Text, { color: index === selectedIndex ? 'green' : option.color || 'white', bold: true },
+                index === selectedIndex ? '➣ ' : '  ',
+                option.label))))));
+}

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

@@ -0,0 +1,15 @@
+import React from 'react';
+export interface Message {
+    role: 'user' | 'assistant' | 'command';
+    content: string;
+    streaming?: boolean;
+    discontinued?: boolean;
+    commandName?: string;
+}
+interface Props {
+    messages: Message[];
+    animationFrame: number;
+    maxMessages?: number;
+}
+export default function MessageList({ messages, animationFrame, maxMessages }: Props): React.JSX.Element | null;
+export {};