corex-cli 1.0.0

package/src/lib/config.ts

@@ -0,0 +1,250 @@
+import Conf from 'conf';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as readline from 'readline';
+import { fileURLToPath } from 'url';
+import { CorexConfig, ThemeName } from '../types.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const FALLBACK_SYSTEM_PROMPT = `You are COREX, an elite AI assistant.
+You are direct, insightful, and technically brilliant.
+Format your responses for terminal display using clean spacing.
+When showing code, use markdown code blocks.
+Keep responses focused and avoid unnecessary filler text.`;
+
+function loadSystemPrompt(): string {
+    const filename = 'COREX_SYSTEM_PROMPT.txt';
+    const possiblePaths = [
+        path.join(__dirname, '..', 'assets', filename),
+        path.join(__dirname, '..', '..', 'assets', filename),
+        path.join(process.cwd(), 'assets', filename),
+    ];
+
+    for (const p of possiblePaths) {
+        try {
+            if (fs.existsSync(p)) {
+                return fs.readFileSync(p, 'utf-8').trim();
+            }
+        } catch {
+            // continue
+        }
+    }
+    return FALLBACK_SYSTEM_PROMPT;
+}
+
+const DEFAULT_SYSTEM_PROMPT = loadSystemPrompt();
+
+const defaults: CorexConfig = {
+    apiKey: '',
+    provider: 'anthropic',
+    model: 'claude-3-5-sonnet-20241022',
+    theme: 'default' as ThemeName,
+    systemPrompt: DEFAULT_SYSTEM_PROMPT,
+    maxTokens: 4096,
+    temperature: 0.7,
+    saveHistory: false,
+    userName: 'You',
+};
+
+const config = new Conf<CorexConfig>({
+    projectName: 'corex',
+    defaults,
+});
+
+export function loadConfig(): CorexConfig | null {
+    try {
+        const apiKey = config.get('apiKey');
+        if (!apiKey) return null;
+        return {
+            apiKey: config.get('apiKey'),
+            provider: config.get('provider'),
+            model: config.get('model'),
+            theme: config.get('theme'),
+            systemPrompt: config.get('systemPrompt'),
+            maxTokens: config.get('maxTokens'),
+            temperature: config.get('temperature'),
+            saveHistory: config.get('saveHistory'),
+            userName: config.get('userName'),
+        };
+    } catch (error) {
+        return null;
+    }
+}
+
+export function saveConfig(partial: Partial<CorexConfig>): void {
+    for (const [key, value] of Object.entries(partial)) {
+        config.set(key as keyof CorexConfig, value as any);
+    }
+}
+
+export function deleteConfig(): void {
+    config.clear();
+}
+
+export function isFirstRun(): boolean {
+    const c = loadConfig();
+    return !c || !c.apiKey;
+}
+
+function detectProvider(key: string): string | null {
+    const k = key.trim();
+    if (k.startsWith('sk-ant-')) return 'anthropic';
+    if (k.startsWith('AIza')) return 'gemini';
+    if (k.startsWith('sk-or-v1-') || k.startsWith('sk-or-')) return 'openrouter';
+    if (k.startsWith('sk-proj-')) return 'openai';
+    if (k.startsWith('sk-') && !k.startsWith('sk-or-')) return 'openai';
+    if (k.startsWith('ds-') || k.toLowerCase().includes('deepseek')) return 'deepseek';
+    return null;
+}
+
+function cleanupStdin() {
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+    }
+    process.stdin.removeAllListeners('data');
+    process.stdin.removeAllListeners('keypress');
+    process.stdin.pause();
+}
+
+function askApiKey(): Promise<string> {
+    return new Promise((resolve) => {
+        process.stdout.write('  API Key ❯ ');
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        let key = '';
+
+        const onData = (chunk: Buffer) => {
+            const chars = chunk.toString();
+            for (let i = 0; i < chars.length; i++) {
+                const ch = chars[i];
+                if (ch === '\r' || ch === '\n') {
+                    process.stdout.write('\n');
+                    process.stdin.setRawMode(false);
+                    process.stdin.removeListener('data', onData);
+                    process.stdin.pause();
+                    resolve(key.trim());
+                    return;
+                } else if (ch === '\x03') {
+                    process.stdout.write('\n');
+                    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+                    process.exit(0);
+                } else if (ch === '\x7f' || ch === '\b') {
+                    if (key.length > 0) {
+                        key = key.slice(0, -1);
+                        process.stdout.clearLine(0);
+                        process.stdout.cursorTo(0);
+                        process.stdout.write('  API Key ❯ ' + '•'.repeat(key.length));
+                    }
+                } else {
+                    key += ch;
+                    process.stdout.write('•'.repeat(ch.length));
+                }
+            }
+        };
+
+        process.stdin.on('data', onData);
+    });
+}
+
+const PROVIDERS = [
+    { id: 'anthropic', label: 'Anthropic (Claude)' },
+    { id: 'gemini', label: 'Google Gemini' },
+    { id: 'openai', label: 'OpenAI (GPT)' },
+    { id: 'openrouter', label: 'OpenRouter' },
+    { id: 'deepseek', label: 'DeepSeek' },
+];
+
+export async function runFirstRunWizard(): Promise<void> {
+    console.log('─────────────────────────────────────────────────────────────────────');
+    console.log('  Enter your API key below and use what you purchased.');
+    console.log('  Supports: Anthropic · Gemini · OpenAI · OpenRouter · DeepSeek');
+    console.log('');
+    console.log('  Your key will be auto-detected. No manual setup needed.');
+    console.log('');
+
+    const apiKey = await askApiKey();
+
+    console.log('');
+
+    const detected = detectProvider(apiKey);
+    let providerId = detected;
+
+    if (detected) {
+        const label = PROVIDERS.find(p => p.id === detected)?.label || detected;
+        console.log(`  \x1b[32m✓ Detected: ${label}\x1b[0m`);
+    } else {
+        console.log('  \x1b[33m⚠ Could not detect provider. Select manually:\x1b[0m');
+        console.log('');
+        
+        let selectedIdx = 0;
+        
+        const printMenu = () => {
+            process.stdout.write('\x1b[?25l'); // hide cursor
+            for (let i = 0; i < PROVIDERS.length; i++) {
+                const prefix = i === selectedIdx ? '  ❯ ' : '    ';
+                console.log(`${prefix}${PROVIDERS[i].label}`);
+            }
+            console.log('\n  Navigate: ↑ ↓   Confirm: Enter');
+        };
+        
+        const clearMenu = () => {
+            // PROVIDERS.length + 2 lines for spacing/nav text
+            process.stdout.write(`\x1b[${PROVIDERS.length + 2}A`);
+        };
+
+        printMenu();
+
+        providerId = await new Promise<string>((resolve) => {
+            const onKey = (chunk: Buffer) => {
+                const key = chunk.toString();
+                if (key === '\x1b[A') { // Up
+                    if (selectedIdx > 0) {
+                        selectedIdx--;
+                        clearMenu();
+                        printMenu();
+                    }
+                } else if (key === '\x1b[B') { // Down
+                    if (selectedIdx < PROVIDERS.length - 1) {
+                        selectedIdx++;
+                        clearMenu();
+                        printMenu();
+                    }
+                } else if (key === '\r' || key === '\n') {
+                    process.stdin.removeListener('data', onKey);
+                    process.stdout.write('\x1b[?25h'); // show cursor
+                    resolve(PROVIDERS[selectedIdx].id);
+                } else if (key === '\x03') {
+                    cleanupStdin();
+                    process.stdout.write('\n');
+                    process.exit(0);
+                }
+            };
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.on('data', onKey);
+        });
+        console.log('');
+    }
+
+    const providerDefaults: Record<string, string> = {
+        anthropic: 'claude-3-5-sonnet-20241022',
+        gemini: 'gemini-1.5-pro',
+        openai: 'gpt-4o',
+        openrouter: 'openai/gpt-4o',
+        deepseek: 'deepseek-chat',
+    };
+
+    saveConfig({ 
+        apiKey, 
+        provider: providerId as any, 
+        model: providerDefaults[providerId || 'openai'] 
+    });
+
+    console.log('─────────────────────────────────────────────────────────────────────');
+    
+    // CRITICAL CLEANUP
+    cleanupStdin();
+}

package/src/lib/history.ts

@@ -0,0 +1,43 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { Message } from '../types.js';
+
+let history: Message[] = [];
+
+export function addMessage(role: 'user' | 'assistant', content: string): void {
+    history.push({ role, content });
+}
+
+export function getHistory(): Message[] {
+    return [...history];
+}
+
+export function clearHistory(): void {
+    history = [];
+}
+
+export function saveSession(): string {
+    const sessionsDir = path.join(os.homedir(), '.corex', 'sessions');
+    if (!fs.existsSync(sessionsDir)) {
+        fs.mkdirSync(sessionsDir, { recursive: true });
+    }
+
+    const now = new Date();
+    const pad = (n: number) => n.toString().padStart(2, '0');
+    const filename = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}_${pad(now.getHours())}-${pad(now.getMinutes())}.txt`;
+    const filepath = path.join(sessionsDir, filename);
+
+    let content = '=== COREX Chat Session ===\n';
+    content += `Date: ${now.toLocaleString()}\n`;
+    content += `Messages: ${history.length}\n`;
+    content += '='.repeat(40) + '\n\n';
+
+    for (const msg of history) {
+        const label = msg.role === 'user' ? 'You' : 'COREX';
+        content += `[${label}]\n${msg.content}\n\n`;
+    }
+
+    fs.writeFileSync(filepath, content, 'utf-8');
+    return filepath;
+}

package/src/lib/markdown.ts

@@ -0,0 +1,3 @@
+export function renderMarkdown(text: string): string {
+    return text;
+}

package/src/themes/themes.ts

@@ -0,0 +1,70 @@
+import { Theme, ThemeName } from '../types.js';
+
+export const theme = {
+    background: '#0B1220',
+    surface: '#0F1E3A',
+    primary: '#3B82F6',
+    highlight: '#93C5FD',
+    textPrimary: '#E5E7EB',
+    textDim: '#6B7280',
+    border: '#1E3A5F',
+    success: '#10B981',
+    error: '#EF4444',
+    warning: '#F59E0B',
+};
+
+export const themes: Record<ThemeName, Theme> = {
+    default: {
+        label: 'Default',
+        userText: theme.textPrimary,
+        aiText: theme.highlight,
+        border: theme.border,
+        accent: theme.primary,
+        statusBar: theme.textDim,
+        headerGradient: [theme.primary, theme.highlight],
+    },
+    matrix: {
+        label: 'Matrix (green hacker)',
+        userText: '#FFFFFF',
+        aiText: '#00FF00',
+        border: '#00FF00',
+        accent: '#00FF00',
+        statusBar: '#003300',
+        headerGradient: ['#00FF00', '#003300'],
+    },
+    cyberpunk: {
+        label: 'Cyberpunk (yellow + magenta)',
+        userText: '#FFFF00',
+        aiText: '#FF00FF',
+        border: '#00FFFF',
+        accent: '#FFFF00',
+        statusBar: '#FF00FF',
+        headerGradient: ['#FFFF00', '#FF00FF'],
+    },
+    ocean: {
+        label: 'Ocean (cyan + blue)',
+        userText: '#00FFFF',
+        aiText: '#0099FF',
+        border: '#00FFFF',
+        accent: '#00FFFF',
+        statusBar: '#003366',
+        headerGradient: ['#00FFFF', '#0000FF'],
+    },
+    blood: {
+        label: 'Blood (red + dark red)',
+        userText: '#FF0000',
+        aiText: '#CC0000',
+        border: '#FF0000',
+        accent: '#FF0000',
+        statusBar: '#330000',
+        headerGradient: ['#FF0000', '#330000'],
+    },
+};
+
+export function getTheme(name: ThemeName): Theme {
+    return themes[name] || themes.default;
+}
+
+export function getThemeNames(): ThemeName[] {
+    return Object.keys(themes) as ThemeName[];
+}

package/src/types/gradient-string.d.ts

@@ -0,0 +1,12 @@
+declare module 'gradient-string' {
+    interface GradientOptions {
+        interpolation?: string;
+    }
+    
+    function gradient(colors: string[], options?: GradientOptions): {
+        (text: string): string;
+        multiline(text: string): string;
+    };
+    
+    export default gradient;
+}

package/src/types.ts

@@ -0,0 +1,34 @@
+export interface Message {
+    role: 'user' | 'assistant';
+    content: string;
+}
+
+export interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+
+export type ThemeName = 'default' | 'matrix' | 'cyberpunk' | 'ocean' | 'blood';
+
+export interface Theme {
+    label: string;
+    userText: string;
+    aiText: string;
+    border: string;
+    accent: string;
+    statusBar: string;
+    headerGradient: string[];
+}
+
+export interface CorexConfig {
+    apiKey: string;
+    provider: 'anthropic' | 'gemini' | 'openai' | 'openrouter' | 'deepseek';
+    model: string;
+    theme: ThemeName;
+    systemPrompt: string;
+    maxTokens: number;
+    temperature: number;
+    saveHistory: boolean;
+    userName: string;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "nodenext",
+        "moduleResolution": "nodenext",
+        "lib": [
+            "ES2022"
+        ],
+        "jsx": "react",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "resolveJsonModule": true
+    },
+    "include": [
+        "src/**/*"
+    ]
+}

package/tsup.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+    entry: ['src/index.ts'],
+    format: ['cjs'],
+    target: 'node18',
+    outDir: 'dist',
+    clean: true,
+    banner: {
+        js: '#!/usr/bin/env node',
+    },
+});