lumina-ai-cli 1.0.0

package/README.md

@@ -0,0 +1,92 @@
+# lumina-ai-cli — Personal AI Assistant CLI
+
+Chat with AI models from OpenAI, Anthropic, Google (Gemini), Groq, Together AI, and custom endpoints — all from your terminal.
+
+## Installation
+
+```bash
+npm install -g lumina-ai-cli
+```
+
+## Quick Start
+
+```bash
+lumina
+```
+
+On first run, you'll be guided through:
+1. Choosing an API provider
+2. Entering your API key (stored locally, never shared)
+3. Selecting a default model
+4. Picking a persona
+5. Setting your token budget
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `lumina` | Start the interactive TUI |
+| `lumina --config` | Re-run setup |
+| `lumina --model <name>` | Override model for session |
+| `lumina --persona <name>` | Override persona for session |
+| `lumina --budget <n>` | Override token budget |
+| `lumina --help` | Show help |
+| `lumina --version` | Show version |
+
+### In-Chat Commands
+
+| Command | Description |
+|---------|-------------|
+| `:q` or `:quit` | Exit |
+| `:m <model>` | Switch model |
+| `:p <persona>` | Switch persona |
+| `:b <budget>` | Switch token budget |
+| `:clear` | Clear chat history |
+| `:save <filename>` | Save conversation to file |
+
+## Provider Setup
+
+### OpenAI
+Get your API key from [platform.openai.com/api-keys](https://platform.openai.com/api-keys)
+
+### Anthropic
+Get your API key from [console.anthropic.com](https://console.anthropic.com)
+
+### Google (Gemini)
+Get your API key from [aistudio.google.com](https://aistudio.google.com)
+
+### Groq
+Get your API key from [console.groq.com](https://console.groq.com)
+
+### Together AI
+Get your API key from [api.together.xyz](https://api.together.xyz)
+
+### Custom
+Any OpenAI-compatible endpoint. Provide your base URL and API key.
+
+## Personas
+
+- **Planner** — Technical architecture and project planning
+- **Coder** — Senior software engineer for clean code
+- **Reviewer** — Brutal code review with severity ratings
+- **Fixer** — Debugger with minimal fixes
+- **General** — Default helpful assistant
+
+## Token Efficiency
+
+Lumina is built for extreme token efficiency:
+- Personas enforce concise responses (default 256 tokens)
+- Every 10 turns, conversation is summarized into a compact memory block
+- Real-time token count and cost display
+- Early truncation when budget exceeded
+
+## Troubleshooting
+
+Invalid API key: Run `lumina --config` to update your key.
+Rate limited: Wait or switch models with `:m <model>`.
+Connection failed: Check your internet connection and API endpoint.
+Model not found: Run `lumina --config` to see available models.
+
+## License
+
+MIT

package/bin/lumina.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { main } from '../src/index.js';
+main(process.argv.slice(2));

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "lumina-ai-cli",
+  "version": "1.0.0",
+  "description": "Personal AI Assistant CLI — chat with AI models from OpenAI, Anthropic, Google, Groq, Together AI and custom endpoints",
+  "main": "src/index.js",
+  "bin": {
+    "lumina": "bin/lumina.js",
+    "lumina-ai-cli": "bin/lumina.js"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "type": "module",
+  "keywords": [
+    "ai",
+    "cli",
+    "chat",
+    "openai",
+    "anthropic",
+    "google",
+    "gemini",
+    "groq",
+    "together",
+    "assistant",
+    "terminal"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.27.0",
+    "@google/generative-ai": "^0.12.0",
+    "chalk": "^5.3.0",
+    "fs-extra": "^11.2.0",
+    "gpt-tokenizer": "^2.1.0",
+    "groq-sdk": "^0.5.0",
+    "highlight.js": "^11.9.0",
+    "ink": "^5.0.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "inquirer": "^9.2.0",
+    "openai": "^4.47.0",
+    "react": "^18.2.0"
+  }
+}

package/src/api/anthropic.js

@@ -0,0 +1,63 @@
+import Anthropic from '@anthropic-ai/sdk';
+import { Provider } from './providers.js';
+
+const ANTHROPIC_MODELS = [
+  'claude-3-5-sonnet-20241022',
+  'claude-3-5-haiku-20241022',
+  'claude-3-opus-20240229',
+  'claude-3-haiku-20240307',
+  'claude-3-sonnet-20240229',
+];
+
+export class AnthropicProvider extends Provider {
+  constructor(config) {
+    super(config);
+    this.client = new Anthropic({
+      apiKey: config.apiKey,
+    });
+  }
+
+  async validateKey() {
+    try {
+      await this.client.messages.create({
+        model: 'claude-3-haiku-20240307',
+        max_tokens: 1,
+        messages: [{ role: 'user', content: 'hi' }]
+      });
+      return true;
+    } catch (err) {
+      if (err.status === 401) throw new Error(err.message);
+      return true;
+    }
+  }
+
+  async listModels() {
+    return ANTHROPIC_MODELS;
+  }
+
+  async chat(messages, options = {}) {
+    this.abortController = new AbortController();
+    const systemMsg = messages.find(m => m.role === 'system');
+    const chatMessages = messages.filter(m => m.role !== 'system').map(m => ({
+      role: m.role === 'assistant' ? 'assistant' : 'user',
+      content: m.content
+    }));
+
+    const stream = await this.client.messages.create({
+      model: options.model || this.config.defaultModel,
+      max_tokens: options.maxTokens || (this.config.tokenBudget === 'unlimited' ? 4096 : this.config.tokenBudget),
+      system: systemMsg?.content || undefined,
+      messages: chatMessages,
+      stream: true,
+    });
+
+    let full = '';
+    for await (const event of stream) {
+      if (event.type === 'content_block_delta' && event.delta?.text) {
+        if (options.onToken) options.onToken(event.delta.text);
+        full += event.delta.text;
+      }
+    }
+    return full;
+  }
+}

package/src/api/custom.js

@@ -0,0 +1,100 @@
+import { Provider } from './providers.js';
+
+export class CustomProvider extends Provider {
+  constructor(config) {
+    super(config);
+    this.baseUrl = config.baseUrl?.replace(/\/+$/, '');
+  }
+
+  async _fetch(path, options = {}) {
+    const url = this.baseUrl ? `${this.baseUrl}${path}` : path;
+    const response = await fetch(url, {
+      headers: {
+        'Authorization': `Bearer ${this.config.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      ...options
+    });
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(err);
+    }
+    return response.json();
+  }
+
+  async validateKey() {
+    try {
+      if (this.baseUrl) {
+        await this._fetch('/models');
+      }
+      return true;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  }
+
+  async listModels() {
+    if (this.baseUrl) {
+      try {
+        const data = await this._fetch('/models');
+        if (data.data) return data.data.map(m => m.id || m.name).sort();
+        if (Array.isArray(data)) return data.map(m => m.id || m.name).sort();
+        return Object.values(data).filter(v => typeof v === 'string').sort();
+      } catch {}
+    }
+    return this.config.availableModels || ['custom-model'];
+  }
+
+  async chat(messages, options = {}) {
+    this.abortController = new AbortController();
+    const url = this.baseUrl ? `${this.baseUrl}/chat/completions` : 'https://api.openai.com/v1/chat/completions';
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.config.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: options.model || this.config.defaultModel,
+        messages,
+        stream: true,
+        max_tokens: options.maxTokens || (this.config.tokenBudget === 'unlimited' ? 4096 : this.config.tokenBudget),
+      }),
+      signal: this.abortController.signal
+    });
+
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(err);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let full = '';
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith('data: ')) continue;
+        const data = trimmed.slice(6);
+        if (data === '[DONE]') continue;
+        try {
+          const parsed = JSON.parse(data);
+          const delta = parsed.choices?.[0]?.delta?.content || '';
+          if (delta && options.onToken) {
+            options.onToken(delta);
+          }
+          full += delta;
+        } catch {}
+      }
+    }
+    return full;
+  }
+}

package/src/api/google.js

@@ -0,0 +1,63 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { Provider } from './providers.js';
+
+export class GoogleProvider extends Provider {
+  constructor(config) {
+    super(config);
+    this.client = new GoogleGenerativeAI(config.apiKey);
+  }
+
+  async validateKey() {
+    try {
+      const model = this.client.getGenerativeModel({ model: 'gemini-1.5-flash' });
+      await model.generateContent('test');
+      return true;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  }
+
+  async listModels() {
+    try {
+      const response = await fetch('https://generativelanguage.googleapis.com/v1/models?key=' + this.config.apiKey);
+      const data = await response.json();
+      if (data.models) {
+        return data.models
+          .filter(m => m.name.startsWith('models/gemini'))
+          .map(m => m.name.replace('models/', ''))
+          .sort();
+      }
+    } catch {}
+    return ['gemini-1.5-pro', 'gemini-1.5-flash', 'gemini-2.0-flash'];
+  }
+
+  async chat(messages, options = {}) {
+    this.abortController = new AbortController();
+    const model = this.client.getGenerativeModel({
+      model: options.model || this.config.defaultModel,
+    });
+
+    const chatMessages = messages.filter(m => m.role !== 'system');
+    let history = chatMessages.slice(0, -1).map(m => ({
+      role: m.role === 'assistant' ? 'model' : 'user',
+      parts: [{ text: m.content }]
+    }));
+
+    const lastMsg = chatMessages[chatMessages.length - 1];
+    const systemMsg = messages.find(m => m.role === 'system');
+
+    const chat = model.startChat({
+      history,
+      systemInstruction: systemMsg?.content || undefined,
+    });
+
+    const result = await chat.sendMessage(lastMsg.content);
+    const response = result.response;
+    const text = response.text();
+
+    if (options.onToken) {
+      options.onToken(text);
+    }
+    return text;
+  }
+}

package/src/api/groq.js

@@ -0,0 +1,45 @@
+import Groq from 'groq-sdk';
+import { Provider } from './providers.js';
+
+export class GroqProvider extends Provider {
+  constructor(config) {
+    super(config);
+    this.client = new Groq({
+      apiKey: config.apiKey,
+    });
+  }
+
+  async validateKey() {
+    try {
+      await this.client.models.list();
+      return true;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  }
+
+  async listModels() {
+    const response = await this.client.models.list();
+    return response.data.map(m => m.id).sort();
+  }
+
+  async chat(messages, options = {}) {
+    this.abortController = new AbortController();
+    const stream = await this.client.chat.completions.create({
+      model: options.model || this.config.defaultModel,
+      messages,
+      stream: true,
+      max_tokens: options.maxTokens || (this.config.tokenBudget === 'unlimited' ? 4096 : this.config.tokenBudget),
+    });
+
+    let full = '';
+    for await (const chunk of stream) {
+      const delta = chunk.choices?.[0]?.delta?.content || '';
+      if (delta && options.onToken) {
+        options.onToken(delta);
+      }
+      full += delta;
+    }
+    return full;
+  }
+}

package/src/api/openai.js

@@ -0,0 +1,50 @@
+import OpenAI from 'openai';
+import { Provider } from './providers.js';
+
+export class OpenAIProvider extends Provider {
+  constructor(config) {
+    super(config);
+    this.client = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseUrl || undefined,
+    });
+  }
+
+  async validateKey() {
+    try {
+      await this.client.models.list();
+      return true;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  }
+
+  async listModels() {
+    const response = await this.client.models.list();
+    return response.data
+      .filter(m => m.id.startsWith('gpt') || m.id.startsWith('o1') || m.id.startsWith('o3'))
+      .map(m => m.id)
+      .sort();
+  }
+
+  async chat(messages, options = {}) {
+    this.abortController = new AbortController();
+    const stream = await this.client.chat.completions.create({
+      model: options.model || this.config.defaultModel,
+      messages,
+      stream: true,
+      max_tokens: options.maxTokens || this.config.tokenBudget === 'unlimited' ? 4096 : this.config.tokenBudget,
+      signal: this.abortController.signal
+    });
+
+    let full = '';
+    for await (const chunk of stream) {
+      const delta = chunk.choices?.[0]?.delta?.content || '';
+      if (delta && options.onToken) {
+        options.onToken(delta);
+      }
+      full += delta;
+    }
+    return full;
+  }
+}

package/src/api/providers.js

@@ -0,0 +1,35 @@
+import { encode } from 'gpt-tokenizer';
+
+export class Provider {
+  constructor(config) {
+    this.config = config;
+    this.abortController = null;
+  }
+
+  async validateKey() {
+    throw new Error('validateKey() must be implemented by subclass');
+  }
+
+  async listModels() {
+    throw new Error('listModels() must be implemented by subclass');
+  }
+
+  async chat(messages, options) {
+    throw new Error('chat() must be implemented by subclass');
+  }
+
+  abort() {
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+  }
+
+  countTokens(text) {
+    if (!text) return 0;
+    try {
+      return encode(text).length;
+    } catch {
+      return Math.ceil(text.length / 4);
+    }
+  }
+}

package/src/api/together.js

@@ -0,0 +1,89 @@
+import { Provider } from './providers.js';
+
+export class TogetherProvider extends Provider {
+  constructor(config) {
+    super(config);
+    this.baseUrl = 'https://api.together.xyz/v1';
+  }
+
+  async _fetch(path, options = {}) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      headers: {
+        'Authorization': `Bearer ${this.config.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      ...options
+    });
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(err);
+    }
+    return response.json();
+  }
+
+  async validateKey() {
+    try {
+      await this._fetch('/models');
+      return true;
+    } catch (err) {
+      throw new Error(err.message);
+    }
+  }
+
+  async listModels() {
+    const data = await this._fetch('/models');
+    return data.map(m => m.id || m.name).sort();
+  }
+
+  async chat(messages, options = {}) {
+    this.abortController = new AbortController();
+    const response = await fetch(`${this.baseUrl}/chat/completions`, {
+      method: 'POST',
+      headers: {
+        'Authorization': `Bearer ${this.config.apiKey}`,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        model: options.model || this.config.defaultModel,
+        messages,
+        stream: true,
+        max_tokens: options.maxTokens || (this.config.tokenBudget === 'unlimited' ? 4096 : this.config.tokenBudget),
+      }),
+      signal: this.abortController.signal
+    });
+
+    if (!response.ok) {
+      const err = await response.text();
+      throw new Error(err);
+    }
+
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let full = '';
+    let buffer = '';
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || !trimmed.startsWith('data: ')) continue;
+        const data = trimmed.slice(6);
+        if (data === '[DONE]') continue;
+        try {
+          const parsed = JSON.parse(data);
+          const delta = parsed.choices?.[0]?.delta?.content || '';
+          if (delta && options.onToken) {
+            options.onToken(delta);
+          }
+          full += delta;
+        } catch {}
+      }
+    }
+    return full;
+  }
+}

package/src/config.js

@@ -0,0 +1,50 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.lumina');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+
+const DEFAULTS = {
+  provider: null,
+  apiKey: null,
+  baseUrl: null,
+  defaultModel: null,
+  availableModels: [],
+  persona: 'general',
+  tokenBudget: 256,
+  firstRun: true,
+  version: '1.0.0'
+};
+
+export function getConfigPath() {
+  return CONFIG_PATH;
+}
+
+export function getConfigDir() {
+  return CONFIG_DIR;
+}
+
+export function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_PATH)) {
+      const raw = fs.readFileSync(CONFIG_PATH, 'utf-8');
+      return { ...DEFAULTS, ...JSON.parse(raw) };
+    }
+  } catch {}
+  return { ...DEFAULTS };
+}
+
+export function saveConfig(config) {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+  try {
+    fs.chmodSync(CONFIG_PATH, 0o600);
+  } catch {}
+}
+
+export function configExists() {
+  return fs.existsSync(CONFIG_PATH);
+}