corex-cli 1.0.0

package/src/core/network/request.ts

@@ -0,0 +1,211 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const LOG_DIR = path.join(__dirname, '..', 'logs');
+const LOG_FILE = path.join(LOG_DIR, 'network.log');
+
+function ensureLogDir(): void {
+    if (!fs.existsSync(LOG_DIR)) {
+        fs.mkdirSync(LOG_DIR, { recursive: true });
+    }
+}
+
+function getTimestamp(): string {
+    return new Date().toISOString();
+}
+
+export function logNetworkEvent(
+    provider: string,
+    statusCode: number | null,
+    errorMessage: string | null,
+    details?: string
+): void {
+    ensureLogDir();
+    const logEntry = [
+        getTimestamp(),
+        `provider=${provider}`,
+        statusCode !== null ? `status=${statusCode}` : 'status=null',
+        errorMessage ? `error=${errorMessage}` : 'error=null',
+        details ? `details=${details}` : '',
+    ].filter(Boolean).join(' | ') + '\n';
+    
+    fs.appendFileSync(LOG_FILE, logEntry);
+}
+
+export async function verifyInternet(): Promise<boolean> {
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 5000);
+        
+        const response = await fetch('https://example.com', {
+            method: 'HEAD',
+            signal: controller.signal,
+        } as RequestInit);
+        
+        clearTimeout(timeoutId);
+        return response.ok;
+    } catch {
+        return false;
+    }
+}
+
+export interface CorexRequestOptions extends RequestInit {
+    timeout?: number;
+}
+
+export class NetworkError extends Error {
+    constructor(
+        message: string,
+        public readonly code: 'NETWORK_OFFLINE' | 'NETWORK_FAILURE' | 'API_ERROR' | 'UNKNOWN',
+        public readonly statusCode?: number,
+        public readonly rawResponse?: string
+    ) {
+        super(message);
+        this.name = 'NetworkError';
+    }
+}
+
+export async function corexRequest(
+    url: string,
+    options: CorexRequestOptions,
+    provider: string
+): Promise<any> {
+    const { timeout = 30000, ...fetchOptions } = options;
+    
+    let response: Response;
+    
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        
+        response = await fetch(url, {
+            ...fetchOptions,
+            signal: controller.signal,
+        } as RequestInit);
+        
+        clearTimeout(timeoutId);
+    } catch (networkError: any) {
+        const isOnline = await verifyInternet();
+        
+        if (!isOnline) {
+            logNetworkEvent(provider, null, 'NETWORK_OFFLINE', networkError.message);
+            throw new NetworkError(
+                'Internet connection unavailable.',
+                'NETWORK_OFFLINE'
+            );
+        }
+        
+        const errorMessage = networkError.code === 'AbortError'
+            ? 'Request timeout'
+            : `Network request failed: ${networkError.message}`;
+        
+        logNetworkEvent(provider, null, 'NETWORK_FAILURE', errorMessage);
+        throw new NetworkError(
+            errorMessage,
+            'NETWORK_FAILURE'
+        );
+    }
+    
+    let rawResponse: string;
+    try {
+        rawResponse = await response.text();
+    } catch (e: any) {
+        logNetworkEvent(provider, response.status, 'READ_RESPONSE_FAILED', e.message);
+        throw new NetworkError(
+            `Failed to read response: ${e.message}`,
+            'NETWORK_FAILURE',
+            response.status
+        );
+    }
+    
+    if (!response.ok) {
+        let errorDetails = '';
+        
+        try {
+            const jsonError = JSON.parse(rawResponse);
+            errorDetails = jsonError.error?.message || jsonError.message || rawResponse;
+        } catch {
+            errorDetails = rawResponse.substring(0, 500);
+        }
+        
+        logNetworkEvent(provider, response.status, 'API_ERROR', errorDetails);
+        
+        throw new NetworkError(
+            formatApiError(response.status, errorDetails),
+            'API_ERROR',
+            response.status,
+            rawResponse
+        );
+    }
+    
+    logNetworkEvent(provider, response.status, null);
+    
+    try {
+        return JSON.parse(rawResponse);
+    } catch (e: any) {
+        if (rawResponse.trim() === '') {
+            return {};
+        }
+        throw new NetworkError(
+            `Invalid JSON response: ${e.message}`,
+            'UNKNOWN',
+            response.status,
+            rawResponse
+        );
+    }
+}
+
+function formatApiError(status: number, errorDetails: string): string {
+    switch (status) {
+        case 401:
+            return 'Invalid API key.';
+        case 403:
+            return 'Access forbidden. Check API key permissions.';
+        case 404:
+            return 'Endpoint not found.';
+        case 429:
+            return 'Rate limit exceeded. Please wait and try again.';
+        case 500:
+            return 'Provider server error. Please try again later.';
+        case 502:
+        case 503:
+        case 504:
+            return 'Provider service unavailable.';
+        default:
+            if (status >= 500) {
+                return `Provider server error (${status}).`;
+            }
+            if (status >= 400) {
+                return `API error (${status}): ${errorDetails}`;
+            }
+            return errorDetails;
+    }
+}
+
+export function parseApiError(error: any, defaultMessage: string): string {
+    if (error instanceof NetworkError) {
+        return error.message;
+    }
+    
+    if (error?.status === 401) {
+        return 'Invalid API key. Run /config to update.';
+    }
+    
+    if (error?.status === 429) {
+        return 'Rate limit exceeded. Please wait and try again.';
+    }
+    
+    if (error?.status >= 500) {
+        return 'Provider service unavailable.';
+    }
+    
+    if (error?.message) {
+        return error.message;
+    }
+    
+    return defaultMessage;
+}

package/src/core/providers/anthropic.ts

@@ -0,0 +1,107 @@
+import { corexRequest, NetworkError } from '../network/request.js';
+import { Message } from '../../types.js';
+
+export interface ProviderConfig {
+    apiKey: string;
+    model: string;
+    systemPrompt: string;
+    temperature: number;
+    maxTokens: number;
+}
+
+export interface ChatResponse {
+    content: string;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+        totalTokens: number;
+    };
+}
+
+export async function chatAnthropic(
+    messages: Message[],
+    userMessage: string,
+    config: ProviderConfig,
+    onToken: (token: string) => void
+): Promise<ChatResponse> {
+    const endpoint = 'https://api.anthropic.com/v1/messages';
+    
+    const formattedMessages = [
+        ...messages.map(m => ({ 
+            role: m.role as 'user' | 'assistant', 
+            content: m.content 
+        })),
+        { role: 'user' as const, content: userMessage }
+    ];
+    
+    const requestBody: any = {
+        model: config.model,
+        max_tokens: config.maxTokens,
+        temperature: config.temperature,
+        system: config.systemPrompt,
+        messages: formattedMessages,
+        stream: true,
+    };
+    
+    const response = await corexRequest(
+        endpoint,
+        {
+            method: 'POST',
+            headers: {
+                'x-api-key': config.apiKey,
+                'anthropic-version': '2023-06-01',
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify(requestBody),
+            timeout: 60000,
+        },
+        'anthropic'
+    );
+    
+    let fullContent = '';
+    let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    
+    if (response && response.forEach) {
+        for (const event of response) {
+            if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                const text = event.delta.text;
+                fullContent += text;
+                onToken(text);
+            }
+            if (event.type === 'message_delta' && event.usage) {
+                usage = {
+                    inputTokens: event.usage.input_tokens || 0,
+                    outputTokens: event.usage.output_tokens || 0,
+                    totalTokens: (event.usage.input_tokens || 0) + (event.usage.output_tokens || 0),
+                };
+            }
+        }
+    }
+    
+    return { content: fullContent, usage };
+}
+
+export async function detectProvider(apiKey: string): Promise<string> {
+    const key = apiKey.trim();
+    
+    if (key.startsWith('sk-ant-')) {
+        return 'anthropic';
+    }
+    if (key.startsWith('AIza')) {
+        return 'gemini';
+    }
+    if (key.startsWith('sk-or-v1-') || key.startsWith('sk-or-')) {
+        return 'openrouter';
+    }
+    if (key.startsWith('sk-proj-')) {
+        return 'openai';
+    }
+    if (key.startsWith('sk-') && !key.startsWith('sk-or-')) {
+        return 'openai';
+    }
+    if (key.startsWith('ds-') || key.toLowerCase().includes('deepseek')) {
+        return 'deepseek';
+    }
+    
+    throw new Error(`Cannot detect provider from API key. Please check your key format.`);
+}

package/src/core/providers/gemini.ts

@@ -0,0 +1,56 @@
+import { corexRequest } from '../network/request.js';
+import { Message } from '../../types.js';
+import { ProviderConfig, ChatResponse } from './anthropic.js';
+
+export async function chatGemini(
+    messages: Message[],
+    userMessage: string,
+    config: ProviderConfig,
+    onToken: (token: string) => void
+): Promise<ChatResponse> {
+    const endpoint = `https://generativelanguage.googleapis.com/v1beta/models/${config.model}:streamGenerateContent?alt=sse`;
+    
+    const contents = [
+        ...messages.map(m => ({
+            role: m.role === 'assistant' ? 'model' : 'user',
+            parts: [{ text: m.content }]
+        })),
+        { role: 'user', parts: [{ text: userMessage }] }
+    ];
+    
+    const response = await corexRequest(
+        endpoint,
+        {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                contents,
+                generationConfig: {
+                    temperature: config.temperature,
+                    maxOutputTokens: config.maxTokens,
+                },
+                systemInstruction: {
+                    parts: [{ text: config.systemPrompt }]
+                }
+            }),
+            timeout: 60000,
+        },
+        'gemini'
+    );
+    
+    let fullContent = '';
+    
+    if (response && response.forEach) {
+        for (const chunk of response) {
+            if (chunk.candidates?.[0]?.content?.parts?.[0]?.text) {
+                const text = chunk.candidates[0].content.parts[0].text;
+                fullContent += text;
+                onToken(text);
+            }
+        }
+    }
+    
+    return { content: fullContent };
+}

package/src/core/providers/index.ts

@@ -0,0 +1,4 @@
+export { chatAnthropic, detectProvider } from './anthropic.js';
+export { chatOpenAI } from './openai.js';
+export { chatGemini } from './gemini.js';
+export type { ProviderConfig, ChatResponse } from './anthropic.js';

package/src/core/providers/openai.ts

@@ -0,0 +1,64 @@
+import { corexRequest } from '../network/request.js';
+import { Message } from '../../types.js';
+import { ProviderConfig, ChatResponse } from './anthropic.js';
+
+export async function chatOpenAI(
+    messages: Message[],
+    userMessage: string,
+    config: ProviderConfig,
+    onToken: (token: string) => void,
+    baseURL: string = 'https://api.openai.com/v1'
+): Promise<ChatResponse> {
+    const endpoint = `${baseURL}/chat/completions`;
+    
+    const formattedMessages = [
+        { role: 'system', content: config.systemPrompt },
+        ...messages.map(m => ({ 
+            role: m.role as 'user' | 'assistant', 
+            content: m.content 
+        })),
+        { role: 'user' as const, content: userMessage }
+    ];
+    
+    const response = await corexRequest(
+        endpoint,
+        {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: config.model,
+                messages: formattedMessages,
+                temperature: config.temperature,
+                max_tokens: config.maxTokens,
+                stream: true,
+            }),
+            timeout: 60000,
+        },
+        baseURL.includes('openrouter') ? 'openrouter' : baseURL.includes('deepseek') ? 'deepseek' : 'openai'
+    );
+    
+    let fullContent = '';
+    let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+    
+    if (response && response.forEach) {
+        for (const chunk of response) {
+            if (chunk.choices?.[0]?.delta?.content) {
+                const text = chunk.choices[0].delta.content;
+                fullContent += text;
+                onToken(text);
+            }
+            if (chunk.usage) {
+                usage = {
+                    inputTokens: chunk.usage.prompt_tokens || 0,
+                    outputTokens: chunk.usage.completion_tokens || 0,
+                    totalTokens: chunk.usage.total_tokens || 0,
+                };
+            }
+        }
+    }
+    
+    return { content: fullContent, usage };
+}

package/src/index.ts

@@ -0,0 +1,62 @@
+import React from 'react';
+import { render } from 'ink';
+import dotenv from 'dotenv';
+import { loadConfig } from './lib/config.js';
+import App from './app.js';
+
+dotenv.config();
+
+const nodeVersion = parseInt(process.version.slice(1).split('.')[0], 10);
+if (nodeVersion < 18) {
+    console.error('COREX requires Node.js 18 or higher.');
+    process.exit(1);
+}
+
+const isRawModeSupported = () => {
+    return process.stdin.isTTY;
+};
+
+async function main(): Promise<void> {
+    const args = process.argv.slice(2);
+    if (args[0] === 'logout') {
+        console.log('Logged out. Run \'corex\' to set up again.');
+        process.exit(0);
+    }
+
+    const defaultConfig = {
+        apiKey: process.env.COREX_API_KEY || '',
+        provider: 'anthropic' as const,
+        model: 'claude-3-5-sonnet-20241022',
+        theme: 'default' as const,
+        systemPrompt: 'You are COREX, an elite AI assistant.',
+        maxTokens: 4096,
+        temperature: 0.7,
+        saveHistory: false,
+        userName: 'You',
+    };
+
+    const savedConfig = loadConfig();
+    const config = savedConfig || defaultConfig;
+
+    if (!isRawModeSupported()) {
+        console.log('\n\x1b[33mWarning: Terminal does not support raw mode.\x1b[0m');
+        console.log('For best experience, run in a proper terminal emulator.\n');
+    }
+
+    const { waitUntilExit } = render(React.createElement(App, { config }));
+
+    await waitUntilExit();
+    process.exit(0);
+}
+
+process.on('SIGINT', () => {
+    try {
+        if (process.stdin.isTTY && process.stdin.isRaw) {
+            process.stdin.setRawMode(false);
+        }
+    } catch (e) {}
+    process.stdout.write('\x1b[?25h\n');
+    process.exit(0);
+});
+
+main();

package/src/lib/ai.ts

@@ -0,0 +1,167 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import OpenAI from 'openai';
+import { Message, TokenUsage, CorexConfig } from '../types.js';
+
+let anthropic: Anthropic | null = null;
+let gemini: GoogleGenerativeAI | null = null;
+let openai: OpenAI | null = null;
+
+export function initAI(apiKey: string, config: CorexConfig): void {
+    const { provider } = config;
+    // Reset clients
+    anthropic = null;
+    gemini = null;
+    openai = null;
+
+    if (provider === 'anthropic') {
+        anthropic = new Anthropic({ apiKey });
+    } else if (provider === 'gemini') {
+        gemini = new GoogleGenerativeAI(apiKey);
+    } else if (provider === 'openai') {
+        openai = new OpenAI({ apiKey });
+    } else if (provider === 'openrouter') {
+        openai = new OpenAI({ 
+            apiKey, 
+            baseURL: 'https://openrouter.ai/api/v1',
+            defaultHeaders: {
+                "HTTP-Referer": "https://github.com/corex-ai", 
+                "X-Title": "COREX CLI",
+            }
+        });
+    } else if (provider === 'deepseek') {
+        openai = new OpenAI({ 
+            apiKey, 
+            baseURL: 'https://api.deepseek.com' 
+        });
+    }
+}
+
+export async function sendMessage(
+    history: Message[],
+    userMessage: string,
+    config: CorexConfig,
+    onToken: (token: string) => void,
+    onComplete: (fullText: string, usage: TokenUsage) => void,
+    onError: (error: Error) => void,
+    imageContent?: string | null
+): Promise<void> {
+    const { provider, model, systemPrompt, temperature, maxTokens } = config;
+
+    try {
+        if (provider === 'anthropic' && anthropic) {
+            const currentMessageContent: any[] = [{ type: 'text', text: userMessage }];
+            if (imageContent) {
+                currentMessageContent.push({
+                    type: 'image',
+                    source: {
+                        type: 'base64',
+                        media_type: 'image/png', // Assuming png for simplicity or detect?
+                        data: imageContent,
+                    }
+                });
+            }
+
+            const stream = anthropic.messages.stream({
+                model,
+                max_tokens: maxTokens,
+                temperature,
+                system: systemPrompt,
+                messages: [
+                    ...history.map(m => ({ 
+                        role: m.role as 'user' | 'assistant', 
+                        content: m.content 
+                    })),
+                    { role: 'user', content: currentMessageContent as any } // Cast because SDK types might be strict
+                ],
+            });
+
+            let fullText = '';
+            stream.on('text', (text) => {
+                fullText += text;
+                onToken(text);
+            });
+
+            const finalMessage = await stream.finalMessage();
+            onComplete(fullText, {
+                inputTokens: finalMessage.usage?.input_tokens || 0,
+                outputTokens: finalMessage.usage?.output_tokens || 0,
+                totalTokens: (finalMessage.usage?.input_tokens || 0) + (finalMessage.usage?.output_tokens || 0),
+            });
+
+        } else if (provider === 'gemini' && gemini) {
+            const genModel = gemini.getGenerativeModel({ model });
+            const chat = genModel.startChat({
+                history: history.map(m => ({ 
+                    role: m.role === 'user' ? 'user' : 'model', 
+                    parts: [{ text: m.content }] 
+                })),
+                generationConfig: { maxOutputTokens: maxTokens, temperature },
+            });
+
+            const parts: any[] = [{ text: userMessage }];
+            if (imageContent) {
+                parts.push({
+                    inlineData: {
+                        mimeType: 'image/png',
+                        data: imageContent
+                    }
+                });
+            }
+
+            const result = await chat.sendMessageStream(parts);
+            let fullText = '';
+            for await (const chunk of result.stream) {
+                const chunkText = chunk.text();
+                fullText += chunkText;
+                onToken(chunkText);
+            }
+            onComplete(fullText, { inputTokens: 0, outputTokens: 0, totalTokens: 0 });
+
+        } else if ((provider === 'openai' || provider === 'openrouter' || provider === 'deepseek') && openai) {
+            let messages: any[] = [
+                { role: 'system', content: systemPrompt },
+                ...history.map(m => ({ role: m.role as 'user' | 'assistant', content: m.content }))
+            ];
+
+            const userMsgObj: any = { role: 'user', content: userMessage };
+            if (imageContent) {
+                userMsgObj.content = [
+                    { type: 'text', text: userMessage },
+                    { 
+                        type: 'image_url', 
+                        image_url: {
+                            url: `data:image/png;base64,${imageContent}`
+                        }
+                    }
+                ];
+            }
+            messages.push(userMsgObj);
+
+            const stream = await openai.chat.completions.create({
+                model,
+                messages,
+                stream: true,
+                temperature,
+                max_tokens: maxTokens,
+            });
+
+            let fullText = '';
+            for await (const chunk of stream) {
+                const content = chunk.choices[0]?.delta?.content || '';
+                if (content) {
+                    fullText += content;
+                    onToken(content);
+                }
+            }
+            onComplete(fullText, { inputTokens: 0, outputTokens: 0, totalTokens: 0 });
+
+        } else {
+            throw new Error(`Provider ${provider} not initialized.`);
+        }
+    } catch (err: any) {
+        let message = err.message || 'An unexpected error occurred.';
+        if (err.status === 401) message = 'Invalid API key. Run /config to update.';
+        onError(new Error(message));
+    }
+}