snow-ai 0.1.12

package/dist/ui/pages/ModelConfigScreen.js

@@ -0,0 +1,239 @@
+import React, { useState, useEffect } from 'react';
+import { Box, Text, useInput } from 'ink';
+import Gradient from 'ink-gradient';
+import { Select, Alert } from '@inkjs/ui';
+import { fetchAvailableModels, filterModels } from '../../api/models.js';
+import { getOpenAiConfig, updateOpenAiConfig, } from '../../utils/apiConfig.js';
+export default function ModelConfigScreen({ onBack, onSave }) {
+    const [advancedModel, setAdvancedModel] = useState('');
+    const [basicModel, setBasicModel] = useState('');
+    const [maxContextTokens, setMaxContextTokens] = useState(4000);
+    const [currentField, setCurrentField] = useState('advancedModel');
+    const [isEditing, setIsEditing] = useState(false);
+    const [models, setModels] = useState([]);
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState('');
+    const [baseUrlMissing, setBaseUrlMissing] = useState(false);
+    const [searchTerm, setSearchTerm] = useState('');
+    useEffect(() => {
+        const config = getOpenAiConfig();
+        setAdvancedModel(config.advancedModel || '');
+        setBasicModel(config.basicModel || '');
+        setMaxContextTokens(config.maxContextTokens || 4000);
+        if (!config.baseUrl) {
+            setBaseUrlMissing(true);
+            return;
+        }
+    }, []);
+    const loadModels = async () => {
+        setLoading(true);
+        setError('');
+        try {
+            const fetchedModels = await fetchAvailableModels();
+            setModels(fetchedModels);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err.message : 'Failed to load models');
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    const getCurrentOptions = () => {
+        const filteredModels = filterModels(models, searchTerm);
+        return filteredModels.map(model => ({
+            label: model.id,
+            value: model.id,
+        }));
+    };
+    const getCurrentValue = () => {
+        if (currentField === 'advancedModel')
+            return advancedModel;
+        if (currentField === 'basicModel')
+            return basicModel;
+        return maxContextTokens.toString();
+    };
+    const handleModelChange = (value) => {
+        if (currentField === 'advancedModel') {
+            setAdvancedModel(value);
+        }
+        else if (currentField === 'basicModel') {
+            setBasicModel(value);
+        }
+        else if (currentField === 'maxContextTokens') {
+            const numValue = parseInt(value, 10);
+            if (!isNaN(numValue) && numValue > 0) {
+                setMaxContextTokens(numValue);
+            }
+        }
+        setIsEditing(false);
+        setSearchTerm(''); // Reset search when selection is made
+    };
+    useInput((input, key) => {
+        if (baseUrlMissing) {
+            if (key.escape) {
+                onBack();
+            }
+            return;
+        }
+        // Don't handle input when Select component is active
+        if (isEditing) {
+            if (currentField === 'maxContextTokens') {
+                // Handle numeric input for maxContextTokens
+                if (input && input.match(/[0-9]/)) {
+                    const newValue = parseInt(maxContextTokens.toString() + input, 10);
+                    if (!isNaN(newValue)) {
+                        setMaxContextTokens(newValue);
+                    }
+                }
+                else if (key.backspace || key.delete) {
+                    const currentStr = maxContextTokens.toString();
+                    const newStr = currentStr.slice(0, -1);
+                    const newValue = parseInt(newStr, 10);
+                    if (!isNaN(newValue)) {
+                        setMaxContextTokens(newValue);
+                    }
+                    else {
+                        setMaxContextTokens(0);
+                    }
+                }
+                else if (key.return) {
+                    // Save value, but enforce minimum of 4000
+                    const finalValue = maxContextTokens < 4000 ? 4000 : maxContextTokens;
+                    setMaxContextTokens(finalValue);
+                    setIsEditing(false);
+                }
+            }
+            else {
+                // Allow typing to filter in edit mode for model selection
+                if (input && input.match(/[a-zA-Z0-9-_.]/)) {
+                    setSearchTerm(prev => prev + input);
+                }
+                else if (key.backspace || key.delete) {
+                    setSearchTerm(prev => prev.slice(0, -1));
+                }
+            }
+            return;
+        }
+        // Handle save/exit globally
+        if (input === 's' && (key.ctrl || key.meta)) {
+            const config = {
+                advancedModel,
+                basicModel,
+                maxContextTokens,
+            };
+            updateOpenAiConfig(config);
+            onSave();
+        }
+        else if (key.escape) {
+            const config = {
+                advancedModel,
+                basicModel,
+                maxContextTokens,
+            };
+            updateOpenAiConfig(config);
+            onBack();
+        }
+        else if (key.return) {
+            // Load models first for model fields, or enter edit mode directly for maxContextTokens
+            setSearchTerm(''); // Reset search when entering edit mode
+            if (currentField === 'maxContextTokens') {
+                setIsEditing(true);
+            }
+            else {
+                loadModels().then(() => {
+                    setIsEditing(true);
+                });
+            }
+        }
+        else if (key.upArrow) {
+            if (currentField === 'basicModel') {
+                setCurrentField('advancedModel');
+            }
+            else if (currentField === 'maxContextTokens') {
+                setCurrentField('basicModel');
+            }
+        }
+        else if (key.downArrow) {
+            if (currentField === 'advancedModel') {
+                setCurrentField('basicModel');
+            }
+            else if (currentField === 'basicModel') {
+                setCurrentField('maxContextTokens');
+            }
+        }
+    });
+    if (baseUrlMissing) {
+        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' }, "Model Configuration"),
+                    React.createElement(Text, { color: "gray", dimColor: true }, "Configure AI models for different tasks"))),
+            React.createElement(Box, { marginBottom: 2 },
+                React.createElement(Alert, { variant: "error" }, "Base URL not configured. Please configure API settings first before setting up models.")),
+            React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Alert, { variant: "info" }, "Press Esc to return to main menu"))));
+    }
+    if (loading) {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Box, { marginBottom: 2, borderStyle: "double", paddingX: 2, paddingY: 1 },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Gradient, { name: "rainbow" }, "Model Configuration"),
+                    React.createElement(Text, { color: "gray", dimColor: true }, "Loading available models...")))));
+    }
+    if (error) {
+        return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+            React.createElement(Box, { marginBottom: 2, borderStyle: "double", borderColor: "red", paddingX: 2, paddingY: 1 },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Gradient, { name: 'rainbow' }, "Model Configuration"),
+                    React.createElement(Text, { color: "gray", dimColor: true }, "Configure AI models for different tasks"))),
+            React.createElement(Box, { marginBottom: 2 },
+                React.createElement(Alert, { variant: "error" }, error)),
+            React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Alert, { variant: "info" }, "Press Esc to return to main menu"))));
+    }
+    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' }, "Model Configuration"),
+                React.createElement(Text, { color: "gray", dimColor: true }, "Configure AI models for different tasks"))),
+        React.createElement(Box, { flexDirection: "column", marginBottom: 2 },
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: currentField === 'advancedModel' ? 'green' : 'white' },
+                        currentField === 'advancedModel' ? '➣ ' : '  ',
+                        "Advanced Model (Main Work):"),
+                    currentField === 'advancedModel' && isEditing && (React.createElement(Box, { marginLeft: 3 }, loading ? (React.createElement(Text, { color: "yellow" }, "Loading models...")) : (React.createElement(Box, { flexDirection: "column" },
+                        searchTerm && (React.createElement(Text, { color: "cyan" },
+                            "Filter: ",
+                            searchTerm)),
+                        React.createElement(Select, { options: getCurrentOptions(), defaultValue: getCurrentValue(), onChange: handleModelChange }))))),
+                    (!isEditing || currentField !== 'advancedModel') && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, advancedModel || 'Not set'))))),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: currentField === 'basicModel' ? 'green' : 'white' },
+                        currentField === 'basicModel' ? '➣ ' : '  ',
+                        "Basic Model (Summary & Analysis):"),
+                    currentField === 'basicModel' && isEditing && (React.createElement(Box, { marginLeft: 3 }, loading ? (React.createElement(Text, { color: "yellow" }, "Loading models...")) : (React.createElement(Box, { flexDirection: "column" },
+                        searchTerm && (React.createElement(Text, { color: "cyan" },
+                            "Filter: ",
+                            searchTerm)),
+                        React.createElement(Select, { options: getCurrentOptions(), defaultValue: getCurrentValue(), onChange: handleModelChange }))))),
+                    (!isEditing || currentField !== 'basicModel') && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, basicModel || 'Not set'))))),
+            React.createElement(Box, { marginBottom: 1 },
+                React.createElement(Box, { flexDirection: "column" },
+                    React.createElement(Text, { color: currentField === 'maxContextTokens' ? 'green' : 'white' },
+                        currentField === 'maxContextTokens' ? '➣ ' : '  ',
+                        "Max Context Tokens (Auto-compress when reached):"),
+                    currentField === 'maxContextTokens' && isEditing && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "cyan" },
+                            "Enter value: ",
+                            maxContextTokens))),
+                    (!isEditing || currentField !== 'maxContextTokens') && (React.createElement(Box, { marginLeft: 3 },
+                        React.createElement(Text, { color: "gray" }, maxContextTokens)))))),
+        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, Ctrl+S or Esc to save"))))));
+}

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

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    version?: string;
+    onMenuSelect?: (value: string) => void;
+};
+export default function WelcomeScreen({ version, onMenuSelect, }: Props): React.JSX.Element;
+export {};

package/dist/ui/pages/WelcomeScreen.js

@@ -0,0 +1,48 @@
+import React, { useState } from 'react';
+import { Box, Text } from 'ink';
+import { Alert } from '@inkjs/ui';
+import Gradient from 'ink-gradient';
+import Menu from '../components/Menu.js';
+export default function WelcomeScreen({ version = '1.0.0', onMenuSelect, }) {
+    const [infoText, setInfoText] = useState('Start a new chat conversation');
+    const menuOptions = [
+        {
+            label: 'Start',
+            value: 'chat',
+            infoText: 'Start a new chat conversation'
+        },
+        {
+            label: 'API Settings',
+            value: 'config',
+            infoText: 'Configure OpenAI API settings',
+        },
+        {
+            label: 'Model Settings',
+            value: 'models',
+            infoText: 'Configure AI models for different tasks',
+        },
+        {
+            label: 'Exit',
+            value: 'exit',
+            color: 'rgb(232, 131, 136)',
+            infoText: 'Exit the application',
+        }
+    ];
+    const handleSelectionChange = (newInfoText) => {
+        setInfoText(newInfoText);
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(Box, { marginBottom: 2, borderStyle: "double", paddingX: 2, paddingY: 1, borderColor: 'cyan' },
+            React.createElement(Box, { flexDirection: "column" },
+                React.createElement(Gradient, { name: "rainbow" },
+                    React.createElement(Text, { bold: true }, "A I B O T P R O")),
+                React.createElement(Text, { color: "blue" }, "C L I"),
+                React.createElement(Text, { color: "gray", dimColor: true }, "Intelligent Command Line Assistant"),
+                React.createElement(Text, { color: "magenta", dimColor: true },
+                    "Version ",
+                    version))),
+        onMenuSelect && (React.createElement(Box, { marginBottom: 0 },
+            React.createElement(Menu, { options: menuOptions, onSelect: onMenuSelect, onSelectionChange: handleSelectionChange }))),
+        React.createElement(Box, { justifyContent: "space-between" },
+            React.createElement(Alert, { variant: 'info' }, infoText))));
+}

package/dist/utils/apiConfig.d.ts

@@ -0,0 +1,17 @@
+export type RequestMethod = 'chat' | 'responses';
+export interface ApiConfig {
+    baseUrl: string;
+    apiKey: string;
+    requestMethod: RequestMethod;
+    advancedModel?: string;
+    basicModel?: string;
+    maxContextTokens?: number;
+}
+export interface AppConfig {
+    openai: ApiConfig;
+}
+export declare function loadConfig(): AppConfig;
+export declare function saveConfig(config: AppConfig): void;
+export declare function updateOpenAiConfig(apiConfig: Partial<ApiConfig>): void;
+export declare function getOpenAiConfig(): ApiConfig;
+export declare function validateApiConfig(config: Partial<ApiConfig>): string[];

package/dist/utils/apiConfig.js

@@ -0,0 +1,86 @@
+import { homedir } from 'os';
+import { join } from 'path';
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs';
+const DEFAULT_CONFIG = {
+    openai: {
+        baseUrl: 'https://api.openai.com/v1',
+        apiKey: '',
+        requestMethod: 'chat',
+        advancedModel: '',
+        basicModel: '',
+        maxContextTokens: 4000,
+    },
+};
+const CONFIG_DIR = join(homedir(), '.aibotpro');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+function ensureConfigDirectory() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+}
+export function loadConfig() {
+    ensureConfigDirectory();
+    if (!existsSync(CONFIG_FILE)) {
+        saveConfig(DEFAULT_CONFIG);
+        return DEFAULT_CONFIG;
+    }
+    try {
+        const configData = readFileSync(CONFIG_FILE, 'utf8');
+        const config = JSON.parse(configData);
+        // Ensure backward compatibility by adding default requestMethod if missing
+        const mergedConfig = {
+            ...DEFAULT_CONFIG,
+            ...config,
+            openai: {
+                ...DEFAULT_CONFIG.openai,
+                ...config.openai,
+                requestMethod: (config.openai?.requestMethod === 'completions' ? 'chat' : config.openai?.requestMethod) || DEFAULT_CONFIG.openai.requestMethod,
+            },
+        };
+        return mergedConfig;
+    }
+    catch (error) {
+        return DEFAULT_CONFIG;
+    }
+}
+export function saveConfig(config) {
+    ensureConfigDirectory();
+    try {
+        const configData = JSON.stringify(config, null, 2);
+        writeFileSync(CONFIG_FILE, configData, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`Failed to save configuration: ${error}`);
+    }
+}
+export function updateOpenAiConfig(apiConfig) {
+    const currentConfig = loadConfig();
+    const updatedConfig = {
+        ...currentConfig,
+        openai: { ...currentConfig.openai, ...apiConfig },
+    };
+    saveConfig(updatedConfig);
+}
+export function getOpenAiConfig() {
+    const config = loadConfig();
+    return config.openai;
+}
+export function validateApiConfig(config) {
+    const errors = [];
+    if (config.baseUrl && !isValidUrl(config.baseUrl)) {
+        errors.push('Invalid base URL format');
+    }
+    if (config.apiKey && config.apiKey.trim().length === 0) {
+        errors.push('API key cannot be empty');
+    }
+    return errors;
+}
+function isValidUrl(url) {
+    try {
+        new URL(url);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/commandExecutor.d.ts

@@ -0,0 +1,11 @@
+export interface CommandResult {
+    success: boolean;
+    message?: string;
+    action?: 'clear' | 'info';
+}
+export interface CommandHandler {
+    execute: () => Promise<CommandResult> | CommandResult;
+}
+export declare function registerCommand(name: string, handler: CommandHandler): void;
+export declare function executeCommand(commandName: string): Promise<CommandResult>;
+export declare function getAvailableCommands(): string[];

package/dist/utils/commandExecutor.js

@@ -0,0 +1,26 @@
+const commandHandlers = {};
+export function registerCommand(name, handler) {
+    commandHandlers[name] = handler;
+}
+export async function executeCommand(commandName) {
+    const handler = commandHandlers[commandName];
+    if (!handler) {
+        return {
+            success: false,
+            message: `Unknown command: ${commandName}`
+        };
+    }
+    try {
+        const result = await handler.execute();
+        return result;
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: error instanceof Error ? error.message : 'Command execution failed'
+        };
+    }
+}
+export function getAvailableCommands() {
+    return Object.keys(commandHandlers);
+}

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

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

package/dist/utils/commands/clear.js

@@ -0,0 +1,12 @@
+import { registerCommand } from '../commandExecutor.js';
+// Clear command handler
+registerCommand('clear', {
+    execute: () => {
+        return {
+            success: true,
+            action: 'clear',
+            message: 'Chat context cleared'
+        };
+    }
+});
+export default {};

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+import { Command } from '../types/index.js';
+export declare function formatCommand(command: Command): string;
+export declare function parseInput(input: string): {
+    command: string;
+    args: string[];
+};
+export declare function sanitizeInput(input: string): string;

package/dist/utils/index.js

@@ -0,0 +1,12 @@
+export function formatCommand(command) {
+    return `${command.name.padEnd(12)} ${command.description}`;
+}
+export function parseInput(input) {
+    const parts = input.trim().split(' ');
+    const command = parts[0] || '';
+    const args = parts.slice(1);
+    return { command, args };
+}
+export function sanitizeInput(input) {
+    return input.trim().replace(/[<>]/g, '');
+}

package/dist/utils/textBuffer.d.ts

@@ -0,0 +1,52 @@
+export interface Viewport {
+    width: number;
+    height: number;
+}
+export interface PastePlaceholder {
+    id: string;
+    content: string;
+    lineCount: number;
+    index: number;
+    placeholder: string;
+}
+export declare class TextBuffer {
+    private lines;
+    private cursorRow;
+    private cursorCol;
+    private viewport;
+    private pendingUpdates;
+    private pasteStorage;
+    private pasteCounter;
+    private lastPasteTime;
+    constructor(viewport: Viewport);
+    get text(): string;
+    /**
+     * 获取完整文本，包括替换占位符为原始内容
+     */
+    getFullText(): string;
+    get visualCursor(): [number, number];
+    get viewportVisualLines(): string[];
+    get maxWidth(): number;
+    private getCurrentLine;
+    private scheduleUpdate;
+    setText(text: string): void;
+    insert(input: string): void;
+    private findBreakPoint;
+    backspace(): void;
+    delete(): void;
+    moveLeft(): void;
+    moveRight(): void;
+    moveUp(): void;
+    moveDown(): void;
+    /**
+     * Update the viewport dimensions, useful for terminal resize handling.
+     */
+    updateViewport(viewport: Viewport): void;
+    /**
+     * Get the character and its visual info at cursor position for proper rendering.
+     */
+    getCharAtCursor(): {
+        char: string;
+        isWideChar: boolean;
+    };
+}