lumina-ai-cli 1.0.0

package/src/index.js

@@ -0,0 +1,124 @@
+import React from 'react';
+import { render } from 'ink';
+import { loadConfig, configExists } from './config.js';
+import { runOnboarding } from './onboarding.js';
+import { OpenAIProvider } from './api/openai.js';
+import { AnthropicProvider } from './api/anthropic.js';
+import { GoogleProvider } from './api/google.js';
+import { GroqProvider } from './api/groq.js';
+import { TogetherProvider } from './api/together.js';
+import { CustomProvider } from './api/custom.js';
+import App from './tui/app.js';
+
+function getProviderInstance(providerName, config) {
+  const providers = {
+    openai: OpenAIProvider,
+    anthropic: AnthropicProvider,
+    google: GoogleProvider,
+    groq: GroqProvider,
+    together: TogetherProvider,
+    custom: CustomProvider,
+  };
+  const Klass = providers[providerName];
+  if (!Klass) throw new Error(`Unknown provider: ${providerName}`);
+  return new Klass(config);
+}
+
+export async function main(args) {
+  const flags = {};
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case '--config':
+      case '-c':
+        flags.reconfig = true;
+        break;
+      case '--model':
+      case '-m':
+        flags.model = args[++i];
+        break;
+      case '--persona':
+      case '-p':
+        flags.persona = args[++i];
+        break;
+      case '--budget':
+      case '-b':
+        flags.budget = args[++i];
+        break;
+      case '--help':
+      case '-h':
+        printHelp();
+        return;
+      case '--version':
+      case '-v':
+        console.log('lumina-ai-cli v1.0.0');
+        return;
+      default:
+        console.log(`Unknown flag: ${args[i]}`);
+        printHelp();
+        process.exit(1);
+    }
+  }
+
+  if (!configExists() || flags.reconfig) {
+    const existing = flags.reconfig ? loadConfig() : null;
+    await runOnboarding(existing);
+    if (flags.reconfig) {
+      const updated = loadConfig();
+      applySessionOverrides(updated, flags);
+      saveAndLaunch(updated);
+    }
+    return;
+  }
+
+  let config = loadConfig();
+
+  if (config.firstRun) {
+    await runOnboarding();
+    config = loadConfig();
+  }
+
+  applySessionOverrides(config, flags);
+  launchTUI(config);
+}
+
+function printHelp() {
+  console.log(`
+lumina-ai-cli - Personal AI Assistant CLI
+
+Usage:
+  lumina                    Start interactive TUI
+  lumina-ai-cli             Same as above
+  lumina --config           Re-run setup
+  lumina --model <model>    Override model for session
+  lumina --persona <name>   Override persona for session
+  lumina --budget <n>       Override token budget (128|256|512|unlimited)
+  lumina --help             Show this help
+  lumina --version          Show version
+`);
+}
+
+function applySessionOverrides(config, flags) {
+  if (flags.model) config.defaultModel = flags.model;
+  if (flags.persona) config.persona = flags.persona;
+  if (flags.budget) {
+    config.tokenBudget = flags.budget === 'unlimited' ? 'unlimited' : parseInt(flags.budget, 10);
+  }
+}
+
+function launchTUI(config) {
+  const provider = getProviderInstance(config.provider, config);
+
+  const { waitUntilExit } = render(
+    React.createElement(App, { provider, initialConfig: config })
+  );
+
+  process.on('SIGINT', () => {
+    process.exit(0);
+  });
+
+  waitUntilExit().catch(() => {});
+}
+
+function saveAndLaunch(config) {
+  launchTUI(config);
+}

package/src/memory.js

@@ -0,0 +1,34 @@
+import { countTokens } from './utils/tokens.js';
+
+export function shouldSummarize(messages) {
+  if (!Array.isArray(messages)) return false;
+  const nonSystem = messages.filter(m => m.role !== 'system');
+  return nonSystem.length > 0 && nonSystem.length % 10 === 0;
+}
+
+export function buildMemoryBlock(summary) {
+  return {
+    role: 'system',
+    content: `[Memory: ${summary}]`,
+    isMemory: true
+  };
+}
+
+export function compressHistory(messages, summary) {
+  const memoryBlock = buildMemoryBlock(summary);
+  const lastTwo = messages.filter(m => m.role !== 'system').slice(-2);
+  const systemMessages = messages.filter(m => m.role === 'system' && !m.isMemory);
+  return [...systemMessages, memoryBlock, ...lastTwo];
+}
+
+export function generateSummaryPrompt(messages) {
+  const text = messages
+    .filter(m => m.role !== 'system')
+    .map(m => `${m.role}: ${m.content}`)
+    .join('\n')
+    .slice(0, 4000);
+  return {
+    role: 'user',
+    content: `Summarize this conversation in under 100 tokens, capturing the key topics and decisions:\n\n${text}`
+  };
+}

package/src/onboarding.js

@@ -0,0 +1,172 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { loadConfig, saveConfig } from './config.js';
+import { OpenAIProvider } from './api/openai.js';
+import { AnthropicProvider } from './api/anthropic.js';
+import { GoogleProvider } from './api/google.js';
+import { GroqProvider } from './api/groq.js';
+import { TogetherProvider } from './api/together.js';
+import { CustomProvider } from './api/custom.js';
+
+function getProvider(providerName, config) {
+  const providers = {
+    openai: OpenAIProvider,
+    anthropic: AnthropicProvider,
+    google: GoogleProvider,
+    groq: GroqProvider,
+    together: TogetherProvider,
+    custom: CustomProvider,
+  };
+  const Klass = providers[providerName];
+  if (!Klass) throw new Error(`Unknown provider: ${providerName}`);
+  return new Klass(config);
+}
+
+async function validateKeyWithRetry(provider, retries = 3) {
+  for (let i = 0; i < retries; i++) {
+    try {
+      await provider.validateKey();
+      return true;
+    } catch (err) {
+      if (i < retries - 1) {
+        console.log(chalk.red(`Validation failed: ${err.message}. Retrying... (${retries - i - 1} attempts left)`));
+        const { retry } = await inquirer.prompt([{
+          type: 'confirm',
+          name: 'retry',
+          message: 'Try again?',
+          default: true
+        }]);
+        if (!retry) return false;
+      } else {
+        console.log(chalk.red(`Validation failed after ${retries} attempts: ${err.message}`));
+        return false;
+      }
+    }
+  }
+  return false;
+}
+
+export async function runOnboarding(existingConfig = null) {
+  console.log(chalk.cyan.bold('\n✦ Welcome to Lumina AI. Let\'s set you up. ✦\n'));
+
+  const defaults = existingConfig || {};
+
+  const { provider } = await inquirer.prompt([{
+    type: 'list',
+    name: 'provider',
+    message: 'Which API provider?',
+    choices: [
+      { name: 'OpenAI', value: 'openai' },
+      { name: 'Anthropic', value: 'anthropic' },
+      { name: 'Google (Gemini)', value: 'google' },
+      { name: 'Groq', value: 'groq' },
+      { name: 'Together AI', value: 'together' },
+      { name: 'Custom (bring your own base URL)', value: 'custom' },
+    ],
+    default: defaults.provider || 'openai'
+  }]);
+
+  const { apiKey } = await inquirer.prompt([{
+    type: 'password',
+    name: 'apiKey',
+    message: 'Enter your API key:',
+    mask: '*',
+    default: defaults.apiKey || '',
+    validate: v => v.length > 0 || 'API key is required'
+  }]);
+
+  let baseUrl = defaults.baseUrl || null;
+  if (provider === 'custom') {
+    const { url } = await inquirer.prompt([{
+      type: 'input',
+      name: 'url',
+      message: 'Enter your custom base URL (e.g. https://api.example.com/v1):',
+      default: baseUrl || '',
+      validate: v => v.length > 0 || 'Base URL is required'
+    }]);
+    baseUrl = url;
+  }
+
+  const config = { provider, apiKey, baseUrl, ...defaults };
+  const instance = getProvider(provider, config);
+
+  console.log(chalk.yellow('\nValidating API key...'));
+  const valid = await validateKeyWithRetry(instance);
+  if (!valid) {
+    console.log(chalk.red('Setup failed. Please try again with a valid API key.'));
+    process.exit(1);
+  }
+  console.log(chalk.green('✓ API key validated\n'));
+
+  console.log(chalk.yellow('Fetching available models...'));
+  let models = [];
+  try {
+    models = await instance.listModels();
+    console.log(chalk.green(`✓ Found ${models.length} models\n`));
+  } catch (err) {
+    console.log(chalk.yellow(`Could not fetch models: ${err.message}`));
+    if (provider === 'custom') {
+      const { manual } = await inquirer.prompt([{
+        type: 'input',
+        name: 'manual',
+        message: 'Enter model names (comma-separated):',
+        default: 'custom-model',
+        validate: v => v.length > 0 || 'At least one model is required'
+      }]);
+      models = manual.split(',').map(m => m.trim());
+    } else {
+      models = defaults.availableModels || ['gpt-4o-mini'];
+    }
+  }
+
+  const { defaultModel } = await inquirer.prompt([{
+    type: 'list',
+    name: 'defaultModel',
+    message: 'Select your default model:',
+    choices: models.map(m => ({ name: m, value: m })),
+    default: defaults.defaultModel || models[0],
+    pageSize: 20
+  }]);
+
+  const { persona } = await inquirer.prompt([{
+    type: 'list',
+    name: 'persona',
+    message: 'Preferred persona?',
+    choices: [
+      { name: 'Planner', value: 'planner' },
+      { name: 'Coder', value: 'coder' },
+      { name: 'Reviewer', value: 'reviewer' },
+      { name: 'Fixer', value: 'fixer' },
+      { name: 'General', value: 'general' },
+    ],
+    default: defaults.persona || 'coder'
+  }]);
+
+  const { tokenBudget } = await inquirer.prompt([{
+    type: 'list',
+    name: 'tokenBudget',
+    message: 'Token budget preference?',
+    choices: [
+      { name: 'Ultra-efficient (128 tokens)', value: 128 },
+      { name: 'Efficient (256 tokens)', value: 256 },
+      { name: 'Balanced (512 tokens)', value: 512 },
+      { name: 'Unlimited', value: 'unlimited' },
+    ],
+    default: defaults.tokenBudget || 256
+  }]);
+
+  const finalConfig = {
+    provider,
+    apiKey,
+    baseUrl,
+    defaultModel,
+    availableModels: models,
+    persona,
+    tokenBudget,
+    firstRun: false,
+    version: '1.0.0'
+  };
+
+  saveConfig(finalConfig);
+  console.log(chalk.green.bold('\n✓ Setup complete. Run ' + chalk.cyan('lumina') + ' or ' + chalk.cyan('lumina-ai-cli') + ' to start.\n'));
+}

package/src/personas/coder.js

@@ -0,0 +1,4 @@
+export default {
+  name: 'coder',
+  systemPrompt: `You are a senior software engineer. Write clean, production-ready code with comments. No explanations unless asked. Use the most efficient algorithm. Include error handling. TOKEN_EFFICIENCY: Output code only. One-line docstring per function. No prose. Max 256 tokens unless user asks for explanation.`
+};

package/src/personas/fixer.js

@@ -0,0 +1,4 @@
+export default {
+  name: 'fixer',
+  systemPrompt: `You are a debugger. Given broken code and/or error messages, output the minimal fix required. Explain the root cause in exactly 1 sentence. TOKEN_EFFICIENCY: Output corrected code only. One-line root cause explanation. No preamble. Max 256 tokens.`
+};

package/src/personas/index.js

@@ -0,0 +1,17 @@
+import planner from './planner.js';
+import coder from './coder.js';
+import reviewer from './reviewer.js';
+import fixer from './fixer.js';
+
+const general = {
+  name: 'general',
+  systemPrompt: `You are a helpful and concise AI assistant. Answer questions directly and accurately. Be efficient with tokens. TOKEN_EFFICIENCY: Be concise. No filler. Max 256 tokens unless user requests more.`
+};
+
+export default {
+  planner,
+  coder,
+  reviewer,
+  fixer,
+  general
+};

package/src/personas/planner.js

@@ -0,0 +1,4 @@
+export default {
+  name: 'planner',
+  systemPrompt: `You are a technical architect and project planner. Break complex tasks into clear, actionable steps. Use bullet points. Be concise. Each step max 3 sentences. Prioritize by impact and effort. TOKEN_EFFICIENCY: Be extremely concise. Use abbreviations. No filler. Max 256 tokens unless user explicitly requests more.`
+};

package/src/personas/reviewer.js

@@ -0,0 +1,4 @@
+export default {
+  name: 'reviewer',
+  systemPrompt: `You are a principal code reviewer. Find bugs, security issues, performance problems, and style violations. Rate severity 1-10. Suggest specific fixes with line references. Be brutal but constructive. TOKEN_EFFICIENCY: Bullet points only. Severity + one-line issue + one-line fix. Max 256 tokens.`
+};

package/src/tui/app.js

@@ -0,0 +1,244 @@
+import React, { useState, useCallback, useEffect, useRef } from 'react';
+import { Box, Text } from 'ink';
+import Spinner from 'ink-spinner';
+import MessageBlock from './chat.js';
+import StatusBar from './statusbar.js';
+import CommandInput from './input.js';
+import { loadConfig, saveConfig } from '../config.js';
+import { countTokens } from '../utils/tokens.js';
+import { estimateCost } from '../utils/cost.js';
+import { saveConversation } from '../utils/files.js';
+import { shouldSummarize, compressHistory, generateSummaryPrompt } from '../memory.js';
+import personas from '../personas/index.js';
+
+const { createElement: h, Fragment } = React;
+
+function App({ provider, initialConfig }) {
+  const [config, setConfig] = useState(initialConfig);
+  const [messages, setMessages] = useState([]);
+  const [input, setInput] = useState('');
+  const [isStreaming, setIsStreaming] = useState(false);
+  const [tokensUsed, setTokensUsed] = useState(0);
+  const [cost, setCost] = useState(0);
+  const [streamingContent, setStreamingContent] = useState('');
+  const [abortController, setAbortController] = useState(null);
+
+  const currentPersona = personas[config.persona] || personas.general;
+
+  useEffect(() => {
+    if (currentPersona) {
+      setMessages([{
+        role: 'system',
+        content: currentPersona.systemPrompt
+      }]);
+    }
+  }, []);
+
+  const handleSubmit = useCallback(async (value) => {
+    if (isStreaming || !value.trim()) return;
+
+    const trimmed = value.trim();
+
+    if (trimmed.startsWith(':')) {
+      handleCommand(trimmed);
+      setInput('');
+      return;
+    }
+
+    const userMsg = { role: 'user', content: trimmed };
+    const newMessages = [...messages, userMsg];
+    setMessages(newMessages);
+    setInput('');
+    setIsStreaming(true);
+    setStreamingContent('');
+
+    try {
+      let full = '';
+      const ac = new AbortController();
+      setAbortController(ac);
+
+      await provider.chat(newMessages, {
+        model: config.defaultModel,
+        maxTokens: config.tokenBudget === 'unlimited' ? 4096 : config.tokenBudget,
+        onToken: (token) => {
+          if (ac.signal.aborted) return;
+          full += token;
+          setStreamingContent(full);
+          const tokCount = countTokens(full, config.defaultModel);
+          setTokensUsed(prev => prev + 1);
+          const c = estimateCost(
+            countTokens(trimmed, config.defaultModel),
+            tokCount,
+            config.defaultModel
+          );
+          setCost(c);
+        },
+        signal: ac.signal
+      });
+
+      const assistantMsg = { role: 'assistant', content: full };
+      const finalMessages = [...newMessages, assistantMsg];
+      setMessages(finalMessages);
+      setStreamingContent('');
+      setIsStreaming(false);
+
+      const tokCount = countTokens(full, config.defaultModel);
+      setTokensUsed(prev => prev + tokCount);
+      const c = estimateCost(
+        countTokens(trimmed, config.defaultModel),
+        tokCount,
+        config.defaultModel
+      );
+      setCost(c);
+
+      if (shouldSummarize(finalMessages)) {
+        const summaryPrompt = generateSummaryPrompt(finalMessages);
+        try {
+          const summary = await provider.chat(
+            [...finalMessages.filter(m => m.role === 'system'), summaryPrompt],
+            { model: config.defaultModel, maxTokens: 150 }
+          );
+          const compressed = compressHistory(finalMessages, summary.slice(0, 500));
+          setMessages(compressed);
+        } catch {}
+      }
+    } catch (err) {
+      if (err.name === 'AbortError') return;
+      setMessages([...newMessages, {
+        role: 'system',
+        content: 'Error: ' + err.message
+      }]);
+      setIsStreaming(false);
+      setStreamingContent('');
+    }
+  }, [messages, isStreaming, config, provider]);
+
+  function handleCommand(cmd) {
+    const parts = cmd.slice(1).split(/\s+/);
+    const command = parts[0];
+    const arg = parts.slice(1).join(' ');
+
+    switch (command) {
+      case 'q':
+      case 'quit':
+        process.exit(0);
+        break;
+      case 'm':
+      case 'model':
+        if (arg) {
+          setConfig(prev => ({ ...prev, defaultModel: arg }));
+          setMessages(prev => [...prev, {
+            role: 'system',
+            content: 'Switched model to ' + arg
+          }]);
+        }
+        break;
+      case 'p':
+      case 'persona':
+        if (arg && personas[arg]) {
+          setConfig(prev => ({ ...prev, persona: arg }));
+          const newPersonaMsg = {
+            role: 'system',
+            content: personas[arg].systemPrompt
+          };
+          setMessages([newPersonaMsg]);
+          setTokensUsed(0);
+          setCost(0);
+        }
+        break;
+      case 'b':
+      case 'budget':
+        const budget = arg === 'unlimited' ? 'unlimited' : parseInt(arg, 10);
+        if (budget === 'unlimited' || [128, 256, 512].includes(budget)) {
+          setConfig(prev => ({ ...prev, tokenBudget: budget }));
+          setMessages(prev => [...prev, {
+            role: 'system',
+            content: 'Token budget set to ' + budget
+          }]);
+        }
+        break;
+      case 'clear':
+        setMessages([{
+          role: 'system',
+          content: currentPersona.systemPrompt
+        }]);
+        setTokensUsed(0);
+        setCost(0);
+        break;
+      case 'save':
+        if (arg) {
+          try {
+            const path = saveConversation(messages, arg);
+            setMessages(prev => [...prev, {
+              role: 'system',
+              content: 'Saved to ' + path
+            }]);
+          } catch (err) {
+            setMessages(prev => [...prev, {
+              role: 'system',
+              content: 'Save failed: ' + err.message
+            }]);
+          }
+        }
+        break;
+      default:
+        setMessages(prev => [...prev, {
+          role: 'system',
+          content: 'Unknown command: :' + command + '. Available: :q, :m <model>, :p <persona>, :b <budget>, :clear, :save <filename>'
+        }]);
+    }
+  }
+
+  const displayMessages = messages.filter(m => !(m.role === 'system' && !m.isMemory));
+  const emptyState = displayMessages.length === 0 || (displayMessages.length === 1 && displayMessages[0].role === 'system');
+
+  const children = [
+    h(Box, {
+      key: 'chat-area',
+      flexDirection: 'column',
+      flexGrow: 1,
+      overflowY: 'auto',
+      paddingX: 1,
+      paddingY: 1
+    },
+      emptyState
+        ? h(Box, { justifyContent: 'center', marginTop: 2 },
+            h(Text, { color: 'gray' }, 'Welcome to Lumina AI. Type a message or :q to exit.')
+          )
+        : displayMessages.map((msg, i) =>
+            h(MessageBlock, { key: i, message: msg })
+          ).concat(
+            isStreaming && streamingContent
+              ? h(MessageBlock, { key: 'streaming', message: { role: 'assistant', content: streamingContent } })
+              : null,
+            isStreaming && !streamingContent
+              ? h(Box, { key: 'spinner', marginY: 1 },
+                  h(Text, { color: 'green' },
+                    h(Spinner, { type: 'dots' }), ' Thinking...'
+                  )
+                )
+              : null
+          ).filter(Boolean)
+    ),
+    h(StatusBar, {
+      key: 'statusbar',
+      model: config.defaultModel,
+      persona: config.persona,
+      tokensUsed,
+      tokenBudget: config.tokenBudget,
+      cost,
+      isStreaming
+    }),
+    h(CommandInput, {
+      key: 'input',
+      value: input,
+      onChange: setInput,
+      onSubmit: handleSubmit,
+      isStreaming
+    })
+  ];
+
+  return h(Box, { flexDirection: 'column', height: '100%' }, ...children);
+}
+
+export default App;

package/src/tui/chat.js

@@ -0,0 +1,52 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+
+const { createElement: h } = React;
+
+function MessageBlock({ message }) {
+  const isUser = message.role === 'user';
+  const isSystem = message.isMemory || message.role === 'system';
+  const content = message.content || '';
+
+  if (isSystem) {
+    return h(Box, { justifyContent: 'center', marginY: 1 },
+      h(Text, { color: 'gray', dim: true }, '\u2500\u2500 ' + content + ' \u2500\u2500')
+    );
+  }
+
+  const segments = content.split(/(```[\s\S]*?```)/g);
+
+  return h(Box, {
+    flexDirection: 'column',
+    marginY: 1,
+    alignItems: isUser ? 'flex-end' : 'flex-start'
+  },
+    h(Text, { bold: true, color: isUser ? 'cyan' : 'white' },
+      isUser ? 'You' : 'Lumina'
+    ),
+    h(Box, {
+      flexDirection: 'column',
+      paddingX: 1,
+      borderStyle: 'single',
+      borderColor: isUser ? 'cyan' : 'gray'
+    },
+      ...segments.map((segment, i) => {
+        if (segment.startsWith('```')) {
+          const lines = segment.split('\n');
+          const lang = lines[0].replace('```', '').trim();
+          const code = lines.slice(1, -1).join('\n');
+          return h(Box, { key: i, flexDirection: 'column', marginY: 1, paddingX: 1 },
+            lang ? h(Text, { color: 'gray', dim: true }, lang) : null,
+            h(Text, null, code)
+          );
+        }
+        if (segment.trim()) {
+          return h(Text, { key: i }, segment);
+        }
+        return null;
+      }).filter(Boolean)
+    )
+  );
+}
+
+export default MessageBlock;

package/src/tui/input.js

@@ -0,0 +1,24 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+import TextInput from 'ink-text-input';
+
+const { createElement: h } = React;
+
+function CommandInput({ value, onChange, onSubmit, isStreaming }) {
+  return h(Box, null,
+    h(Box, { marginRight: 1 },
+      h(Text, { color: 'cyan' }, '>')
+    ),
+    h(Box, { flexGrow: 1 },
+      h(TextInput, {
+        value,
+        onChange,
+        onSubmit,
+        placeholder: isStreaming ? 'Waiting for response...' : 'Type a message or :q to quit',
+        focus: !isStreaming
+      })
+    )
+  );
+}
+
+export default CommandInput;