matex-cli 1.0.0

package/package.json

@@ -0,0 +1,44 @@
+{
+    "name": "matex-cli",
+    "version": "1.0.0",
+    "description": "Official CLI tool for MATEX AI - Access powerful AI models from your terminal",
+    "main": "dist/index.js",
+    "bin": {
+        "matex": "bin/matex"
+    },
+    "scripts": {
+        "build": "tsc",
+        "dev": "tsc --watch",
+        "test": "jest",
+        "prepublishOnly": "npm run build"
+    },
+    "keywords": [
+        "ai",
+        "cli",
+        "matex",
+        "chatgpt",
+        "coding",
+        "assistant"
+    ],
+    "author": "Ajay Sharma <ajaypoudel47@gmail.com>",
+    "license": "MIT",
+    "dependencies": {
+        "axios": "^1.6.0",
+        "chalk": "^4.1.2",
+        "commander": "^11.1.0",
+        "conf": "^11.0.2",
+        "inquirer": "^8.2.5",
+        "ora": "^5.4.1",
+        "dotenv": "^16.3.1"
+    },
+    "devDependencies": {
+        "@types/inquirer": "^9.0.7",
+        "@types/node": "^20.10.0",
+        "typescript": "^5.3.0",
+        "jest": "^29.7.0",
+        "@types/jest": "^29.5.0"
+    },
+    "engines": {
+        "node": ">=16.0.0"
+    }
+}

package/src/api/client.ts

@@ -0,0 +1,116 @@
+import axios, { AxiosInstance } from 'axios';
+
+export interface ChatMessage {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+
+export interface ChatRequest {
+    messages: ChatMessage[];
+    model: string;
+    temperature?: number;
+    max_tokens?: number;
+    stream?: boolean;
+}
+
+export class MatexAPIClient {
+    private client: AxiosInstance;
+    private apiKey: string;
+    private baseURL: string;
+
+    constructor(apiKey: string, baseURL: string = 'https://matexai-backend-550499663766.us-central1.run.app') {
+        this.apiKey = apiKey;
+        this.baseURL = baseURL;
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            headers: {
+                'X-API-Key': this.apiKey,
+                'Content-Type': 'application/json',
+            },
+            timeout: 60000, // 60 seconds
+        });
+    }
+
+    /**
+     * Send a chat request to the API
+     */
+    async chat(request: ChatRequest): Promise<string> {
+        try {
+            const response = await this.client.post('/api/v1/chat', {
+                ...request,
+                uid: 'cli-user', // Placeholder, backend uses API key for auth
+            });
+
+            // Handle streaming response
+            if (request.stream) {
+                return this.handleStreamingResponse(response.data);
+            }
+
+            return response.data;
+        } catch (error: any) {
+            if (error.response) {
+                throw new Error(`API Error: ${error.response.data.detail || error.response.statusText}`);
+            } else if (error.request) {
+                throw new Error('No response from server. Please check your internet connection.');
+            } else {
+                throw new Error(`Request failed: ${error.message}`);
+            }
+        }
+    }
+
+    /**
+     * Handle Server-Sent Events (SSE) streaming response
+     */
+    private async handleStreamingResponse(data: any): Promise<string> {
+        let fullResponse = '';
+
+        // Parse SSE format: "data: {...}\n\n"
+        const lines = data.split('\n');
+
+        for (const line of lines) {
+            if (line.startsWith('data: ')) {
+                const jsonStr = line.substring(6);
+
+                if (jsonStr === '[DONE]') {
+                    break;
+                }
+
+                try {
+                    const parsed = JSON.parse(jsonStr);
+                    if (parsed.content) {
+                        fullResponse += parsed.content;
+                    }
+                } catch (e) {
+                    // Skip invalid JSON
+                }
+            }
+        }
+
+        return fullResponse;
+    }
+
+    /**
+     * List available API keys (requires Firebase token, not for CLI use)
+     */
+    async listAPIKeys(): Promise<any> {
+        const response = await this.client.get('/api/v1/api-keys/list');
+        return response.data;
+    }
+
+    /**
+     * Test API key validity
+     */
+    async testConnection(): Promise<boolean> {
+        try {
+            await this.chat({
+                messages: [{ role: 'user', content: 'test' }],
+                model: 'matexcodex',
+                max_tokens: 10,
+            });
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+}

package/src/commands/ask.ts

@@ -0,0 +1,62 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../utils/config';
+import { MatexAPIClient } from '../api/client';
+import { spinner } from '../utils/spinner';
+
+export const askCommand = new Command('ask')
+    .description('Ask a single question to MATEX AI')
+    .argument('<question>', 'Your question')
+    .option('-m, --model <model>', 'AI model to use (matexcodex, matexai, elite, matexspirit)', configManager.getDefaultModel())
+    .option('-t, --temperature <number>', 'Temperature (0-1)', '0.7')
+    .option('--max-tokens <number>', 'Maximum tokens in response', '4000')
+    .action(async (question: string, options: any) => {
+        try {
+            // Check for API key
+            const apiKey = configManager.getAPIKey();
+            if (!apiKey) {
+                console.error(chalk.red('❌ No API key configured.'));
+                console.log(chalk.yellow('Run: matex config set-key <your-api-key>'));
+                process.exit(1);
+            }
+
+            // Create API client
+            const client = new MatexAPIClient(apiKey, configManager.getBaseURL());
+
+            // Show thinking indicator
+            spinner.start(`Thinking with ${options.model}...`);
+
+            // Send request
+            const response = await client.chat({
+                messages: [
+                    { role: 'user', content: question }
+                ],
+                model: options.model,
+                temperature: parseFloat(options.temperature),
+                max_tokens: parseInt(options.maxTokens),
+                stream: false,
+            });
+
+            spinner.succeed('Response received!');
+
+            // Display response
+            console.log(chalk.cyan('\n💬 MATEX AI:\n'));
+            console.log(chalk.white(response));
+            console.log();
+
+        } catch (error: any) {
+            spinner.fail('Request failed');
+
+            if (error.message.includes('403')) {
+                console.error(chalk.red('\n❌ Invalid or revoked API key.'));
+                console.log(chalk.yellow('Please check your API key or generate a new one from the MATEX AI platform.'));
+            } else if (error.message.includes('429')) {
+                console.error(chalk.red('\n❌ Rate limit exceeded.'));
+                console.log(chalk.yellow('Please wait a moment before trying again.'));
+            } else {
+                console.error(chalk.red(`\n❌ Error: ${error.message}`));
+            }
+
+            process.exit(1);
+        }
+    });

package/src/commands/chat.ts

@@ -0,0 +1,101 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+import { configManager } from '../utils/config';
+import { MatexAPIClient, ChatMessage } from '../api/client';
+import { spinner } from '../utils/spinner';
+
+export const chatCommand = new Command('chat')
+    .description('Start an interactive chat session with MATEX AI')
+    .option('-m, --model <model>', 'AI model to use (matexcodex, matexai, elite, matexspirit)', configManager.getDefaultModel())
+    .action(async (options: any) => {
+        try {
+            // Check for API key
+            const apiKey = configManager.getAPIKey();
+            if (!apiKey) {
+                console.error(chalk.red('❌ No API key configured.'));
+                console.log(chalk.yellow('Run: matex config set-key <your-api-key>'));
+                process.exit(1);
+            }
+
+            // Create API client
+            const client = new MatexAPIClient(apiKey, configManager.getBaseURL());
+
+            // Welcome message
+            console.log(chalk.bold.cyan('\n🤖 MATEX AI Interactive Chat'));
+            console.log(chalk.gray(`Model: ${options.model}`));
+            console.log(chalk.gray('Type "exit" or "quit" to end the session\n'));
+
+            // Conversation history
+            const messages: ChatMessage[] = [];
+
+            // Chat loop
+            while (true) {
+                // Get user input
+                const { userMessage } = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'userMessage',
+                        message: chalk.green('You:'),
+                        prefix: '',
+                    },
+                ]);
+
+                // Check for exit
+                if (userMessage.toLowerCase() === 'exit' || userMessage.toLowerCase() === 'quit') {
+                    console.log(chalk.cyan('\n👋 Goodbye!\n'));
+                    break;
+                }
+
+                // Skip empty messages
+                if (!userMessage.trim()) {
+                    continue;
+                }
+
+                // Add user message to history
+                messages.push({ role: 'user', content: userMessage });
+
+                // Show thinking indicator
+                spinner.start('Thinking...');
+
+                try {
+                    // Send request
+                    const response = await client.chat({
+                        messages: messages,
+                        model: options.model,
+                        temperature: 0.7,
+                        max_tokens: 4000,
+                        stream: false,
+                    });
+
+                    spinner.stop();
+
+                    // Add assistant response to history
+                    messages.push({ role: 'assistant', content: response });
+
+                    // Display response
+                    console.log(chalk.cyan('AI:'), chalk.white(response));
+                    console.log();
+
+                } catch (error: any) {
+                    spinner.fail('Request failed');
+
+                    if (error.message.includes('403')) {
+                        console.error(chalk.red('❌ Invalid or revoked API key.'));
+                        break;
+                    } else if (error.message.includes('429')) {
+                        console.error(chalk.red('❌ Rate limit exceeded. Please wait a moment.'));
+                    } else {
+                        console.error(chalk.red(`❌ Error: ${error.message}`));
+                    }
+
+                    // Remove failed message from history
+                    messages.pop();
+                }
+            }
+
+        } catch (error: any) {
+            console.error(chalk.red(`\n❌ Chat session error: ${error.message}`));
+            process.exit(1);
+        }
+    });

package/src/commands/config.ts

@@ -0,0 +1,78 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../utils/config';
+import { spinner } from '../utils/spinner';
+
+export const configCommand = new Command('config')
+    .description('Manage MATEX CLI configuration');
+
+// Set API key
+configCommand
+    .command('set-key <apiKey>')
+    .description('Set your MATEX AI API key')
+    .action((apiKey: string) => {
+        try {
+            // Validate API key format
+            if (!apiKey.startsWith('sk-matex-')) {
+                console.error(chalk.red('❌ Invalid API key format. API keys should start with "sk-matex-"'));
+                process.exit(1);
+            }
+
+            configManager.setAPIKey(apiKey);
+            console.log(chalk.green('✅ API key saved successfully!'));
+            console.log(chalk.gray('Your API key is stored securely in ~/.matex/config.json'));
+            console.log(chalk.cyan('\n💡 Try it out: matex ask "What is 2+2?"'));
+        } catch (error: any) {
+            console.error(chalk.red(`❌ Failed to save API key: ${error.message}`));
+            process.exit(1);
+        }
+    });
+
+// Show configuration
+configCommand
+    .command('show')
+    .description('Show current configuration')
+    .action(() => {
+        const config = configManager.getAll();
+
+        console.log(chalk.bold.cyan('\n📋 MATEX CLI Configuration\n'));
+
+        if (config.apiKey) {
+            const maskedKey = config.apiKey.substring(0, 12) + '...' + config.apiKey.substring(config.apiKey.length - 4);
+            console.log(chalk.white('API Key:       ') + chalk.gray(maskedKey));
+        } else {
+            console.log(chalk.white('API Key:       ') + chalk.red('Not set'));
+        }
+
+        console.log(chalk.white('Default Model: ') + chalk.cyan(config.defaultModel || 'matexcodex'));
+        console.log(chalk.white('Base URL:      ') + chalk.gray(config.baseURL || 'https://matexai-backend-550499663766.us-central1.run.app'));
+
+        if (!config.apiKey) {
+            console.log(chalk.yellow('\n⚠️  No API key configured. Use "matex config set-key <your-api-key>" to get started.'));
+        }
+    });
+
+// Clear configuration
+configCommand
+    .command('clear')
+    .description('Clear all configuration')
+    .action(() => {
+        configManager.clear();
+        console.log(chalk.green('✅ Configuration cleared successfully!'));
+    });
+
+// Set default model
+configCommand
+    .command('set-model <model>')
+    .description('Set default AI model')
+    .action((model: string) => {
+        const validModels = ['matexcodex', 'matexai', 'elite', 'matexspirit'];
+
+        if (!validModels.includes(model.toLowerCase())) {
+            console.error(chalk.red(`❌ Invalid model. Choose from: ${validModels.join(', ')}`));
+            process.exit(1);
+        }
+
+        configManager.setDefaultModel(model.toLowerCase());
+        console.log(chalk.green(`✅ Default model set to: ${model}`));
+    });

package/src/commands/models.ts

@@ -0,0 +1,81 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configManager } from '../utils/config';
+
+const AVAILABLE_MODELS = [
+    {
+        name: 'matexcodex',
+        description: 'Best for coding, technical tasks, and development',
+        tier: 'Free (5 min/day), Starter (4M tokens/month), Pro Plus (unlimited)',
+    },
+    {
+        name: 'matexai',
+        description: 'General purpose AI for conversations and knowledge',
+        tier: 'Pro, Pro Plus',
+    },
+    {
+        name: 'elite',
+        description: 'Premium model with advanced capabilities',
+        tier: 'Elite Plan',
+    },
+    {
+        name: 'matexspirit',
+        description: 'Specialized model for creative and empathetic responses',
+        tier: 'Pro, Pro Plus',
+    },
+];
+
+export const modelsCommand = new Command('models')
+    .description('Manage AI models');
+
+// List available models
+modelsCommand
+    .command('list')
+    .description('List all available AI models')
+    .action(() => {
+        console.log(chalk.bold.cyan('\n🤖 Available MATEX AI Models\n'));
+
+        AVAILABLE_MODELS.forEach((model) => {
+            console.log(chalk.bold.white(`${model.name}`));
+            console.log(chalk.gray(`  ${model.description}`));
+            console.log(chalk.yellow(`  Access: ${model.tier}`));
+            console.log();
+        });
+
+        const currentModel = configManager.getDefaultModel();
+        console.log(chalk.cyan(`Current default: ${currentModel}`));
+    });
+
+// Set default model
+modelsCommand
+    .command('set <model>')
+    .description('Set default AI model')
+    .action((model: string) => {
+        const validModels = AVAILABLE_MODELS.map(m => m.name);
+
+        if (!validModels.includes(model.toLowerCase())) {
+            console.error(chalk.red(`❌ Invalid model. Choose from: ${validModels.join(', ')}`));
+            process.exit(1);
+        }
+
+        configManager.setDefaultModel(model.toLowerCase());
+        console.log(chalk.green(`✅ Default model set to: ${model}`));
+    });
+
+// Show current model
+modelsCommand
+    .command('current')
+    .description('Show current default model')
+    .action(() => {
+        const currentModel = configManager.getDefaultModel();
+        const modelInfo = AVAILABLE_MODELS.find(m => m.name === currentModel);
+
+        console.log(chalk.bold.cyan('\n📌 Current Default Model\n'));
+        console.log(chalk.bold.white(currentModel));
+
+        if (modelInfo) {
+            console.log(chalk.gray(modelInfo.description));
+            console.log(chalk.yellow(`Access: ${modelInfo.tier}`));
+        }
+        console.log();
+    });

package/src/index.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { configCommand } from './commands/config';
+import { askCommand } from './commands/ask';
+import { chatCommand } from './commands/chat';
+import { modelsCommand } from './commands/models';
+
+const program = new Command();
+
+program
+    .name('matex')
+    .description('Official CLI tool for MATEX AI - Access powerful AI models from your terminal')
+    .version('1.0.0');
+
+// ASCII Art Banner
+const banner = `
+${chalk.cyan('╔═══════════════════════════════════════╗')}
+${chalk.cyan('║')}     ${chalk.bold.white('MATEX AI')} ${chalk.gray('- Terminal Edition')}    ${chalk.cyan('║')}
+${chalk.cyan('╚═══════════════════════════════════════╝')}
+`;
+
+// Show banner on help
+program.on('--help', () => {
+    console.log(banner);
+    console.log(chalk.gray('\nExamples:'));
+    console.log(chalk.white('  $ matex config set-key sk-matex-xxxxx'));
+    console.log(chalk.white('  $ matex ask "What is 2+2?"'));
+    console.log(chalk.white('  $ matex chat'));
+    console.log(chalk.white('  $ matex models list'));
+    console.log();
+    console.log(chalk.gray('Get your API key from: ') + chalk.cyan('https://matexai.space/platform'));
+    console.log();
+});
+
+// Add commands
+program.addCommand(configCommand);
+program.addCommand(askCommand);
+program.addCommand(chatCommand);
+program.addCommand(modelsCommand);
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+    console.log(banner);
+    program.outputHelp();
+}

package/src/utils/config.ts

@@ -0,0 +1,120 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export interface Config {
+    apiKey?: string;
+    defaultModel?: string;
+    baseURL?: string;
+}
+
+export class ConfigManager {
+    private configDir: string;
+    private configPath: string;
+
+    constructor() {
+        this.configDir = path.join(os.homedir(), '.matex');
+        this.configPath = path.join(this.configDir, 'config.json');
+
+        // Ensure config directory exists
+        if (!fs.existsSync(this.configDir)) {
+            fs.mkdirSync(this.configDir, { recursive: true });
+        }
+    }
+
+    /**
+     * Load config from file
+     */
+    private loadConfig(): Config {
+        if (!fs.existsSync(this.configPath)) {
+            return {};
+        }
+
+        try {
+            const data = fs.readFileSync(this.configPath, 'utf-8');
+            return JSON.parse(data);
+        } catch (error) {
+            return {};
+        }
+    }
+
+    /**
+     * Save config to file
+     */
+    private saveConfig(config: Config): void {
+        fs.writeFileSync(this.configPath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+
+    /**
+     * Set API key
+     */
+    setAPIKey(apiKey: string): void {
+        const config = this.loadConfig();
+        config.apiKey = apiKey;
+        this.saveConfig(config);
+    }
+
+    /**
+     * Get API key
+     */
+    getAPIKey(): string | undefined {
+        return this.loadConfig().apiKey;
+    }
+
+    /**
+     * Set default model
+     */
+    setDefaultModel(model: string): void {
+        const config = this.loadConfig();
+        config.defaultModel = model;
+        this.saveConfig(config);
+    }
+
+    /**
+     * Get default model
+     */
+    getDefaultModel(): string {
+        return this.loadConfig().defaultModel || 'matexcodex';
+    }
+
+    /**
+     * Set base URL
+     */
+    setBaseURL(url: string): void {
+        const config = this.loadConfig();
+        config.baseURL = url;
+        this.saveConfig(config);
+    }
+
+    /**
+     * Get base URL
+     */
+    getBaseURL(): string {
+        return this.loadConfig().baseURL || 'https://matexai-backend-550499663766.us-central1.run.app';
+    }
+
+    /**
+     * Get all config
+     */
+    getAll(): Config {
+        return this.loadConfig();
+    }
+
+    /**
+     * Clear all config
+     */
+    clear(): void {
+        if (fs.existsSync(this.configPath)) {
+            fs.unlinkSync(this.configPath);
+        }
+    }
+
+    /**
+     * Check if API key is set
+     */
+    hasAPIKey(): boolean {
+        return !!this.getAPIKey();
+    }
+}
+
+export const configManager = new ConfigManager();