lumina-ai-cli 1.0.0

package/src/tui/statusbar.js

@@ -0,0 +1,42 @@
+import React from 'react';
+import { Box, Text } from 'ink';
+
+const { createElement: h } = React;
+
+function StatusBar({ model, persona, tokensUsed, tokenBudget, cost, isStreaming }) {
+  const budgetStr = tokenBudget === 'unlimited' ? '\u221E' : String(tokenBudget);
+  const usedPct = tokenBudget === 'unlimited'
+    ? '--'
+    : Math.min(100, Math.round((tokensUsed / tokenBudget) * 100)) + '%';
+  const costStr = cost ? '$' + cost.toFixed(4) : '$0.0000';
+
+  const children = [
+    h(Box, { key: 'left', flexGrow: 1 },
+      h(Text, null,
+        h(Text, { color: 'cyan' }, 'Model:'), ' ' + model + ' ',
+        h(Text, { color: 'cyan' }, 'Persona:'), ' ' + persona
+      )
+    ),
+    h(Box, { key: 'center' },
+      h(Text, null,
+        h(Text, { color: 'yellow' }, 'Tokens:'), ' ' + tokensUsed + '/' + budgetStr + ' ',
+        h(Text, { color: 'yellow' }, 'Used:'), ' ' + usedPct
+      )
+    ),
+    h(Box, { key: 'cost', marginLeft: 2 },
+      h(Text, { color: 'green' }, costStr)
+    ),
+    isStreaming ? h(Box, { key: 'streaming', marginLeft: 2 },
+      h(Text, { color: 'green' }, '\u25CF Streaming...')
+    ) : null
+  ].filter(Boolean);
+
+  return h(Box, {
+    borderStyle: 'single',
+    borderColor: 'gray',
+    paddingX: 1,
+    paddingY: 0
+  }, ...children);
+}
+
+export default StatusBar;

package/src/tui/syntax.js

@@ -0,0 +1,37 @@
+import hljs from 'highlight.js';
+import chalk from 'chalk';
+
+export function highlightCode(code, language) {
+  try {
+    const lang = language || detectLanguage(code);
+    if (lang && hljs.getLanguage(lang)) {
+      const result = hljs.highlight(code, { language: lang });
+      return applyTerminalColors(result.value);
+    }
+  } catch {}
+  return code;
+}
+
+function detectLanguage(code) {
+  if (/^import\s+|^export\s+|^const\s+\w+\s*=|^function\s|^class\s|=>/.test(code)) return 'javascript';
+  if (/^from\s+|^def\s+|^import\s+\w+$/.test(code)) return 'python';
+  if (/^#include|^using\s+namespace|^int\s+main/.test(code)) return 'cpp';
+  if (/^package\s+|^import\s+java/.test(code)) return 'java';
+  if (/^fn\s+|^let\s+|^mut\s+|^impl\s+/.test(code)) return 'rust';
+  if (/^<[^>]+>/.test(code)) return 'html';
+  return null;
+}
+
+function applyTerminalColors(html) {
+  return html
+    .replace(/<span class="hljs-keyword">([^<]+)<\/span>/g, (_, m) => chalk.magenta(m))
+    .replace(/<span class="hljs-string">([^<]+)<\/span>/g, (_, m) => chalk.green(m))
+    .replace(/<span class="hljs-number">([^<]+)<\/span>/g, (_, m) => chalk.yellow(m))
+    .replace(/<span class="hljs-comment">([^<]+)<\/span>/g, (_, m) => chalk.gray(m))
+    .replace(/<span class="hljs-title">([^<]+)<\/span>/g, (_, m) => chalk.blue(m))
+    .replace(/<span class="hljs-built_in">([^<]+)<\/span>/g, (_, m) => chalk.cyan(m))
+    .replace(/<span class="hljs-attr">([^<]+)<\/span>/g, (_, m) => chalk.red(m))
+    .replace(/<span class="hljs-selector-tag">([^<]+)<\/span>/g, (_, m) => chalk.magenta(m))
+    .replace(/<span class="hljs-selector-class">([^<]+)<\/span>/g, (_, m) => chalk.yellow(m))
+    .replace(/<span class="hljs-([^"]+)">([^<]+)<\/span>/g, (_, __, m) => chalk.white(m));
+}

package/src/utils/cost.js

@@ -0,0 +1,33 @@
+const PRICING = {
+  'gpt-4o':           { input: 2.50,  output: 10.00 },
+  'gpt-4o-mini':      { input: 0.15,  output: 0.60 },
+  'gpt-3.5-turbo':    { input: 0.50,  output: 1.50 },
+  'claude-3-5-sonnet':{ input: 3.00,  output: 15.00 },
+  'claude-3-opus':    { input: 15.00, output: 75.00 },
+  'claude-3-haiku':   { input: 0.25,  output: 1.25 },
+  'gemini-1.5-pro':   { input: 1.25,  output: 5.00 },
+  'gemini-1.5-flash': { input: 0.075, output: 0.30 },
+  'gemini-2.0-flash': { input: 0.10,  output: 0.40 },
+  'mixtral-8x7b':     { input: 0.24,  output: 0.24 },
+  'llama2-70b':       { input: 0.59,  output: 0.79 },
+  'llama3-70b':       { input: 0.59,  output: 0.79 },
+  'llama3-8b':        { input: 0.06,  output: 0.06 },
+  'llama-3.3-70b':    { input: 0.59,  output: 0.79 },
+  'deepseek-r1':      { input: 0.55,  output: 0.55 },
+};
+
+export function getPricing(model) {
+  for (const [key, price] of Object.entries(PRICING)) {
+    if (model.toLowerCase().includes(key)) {
+      return price;
+    }
+  }
+  return { input: 1.00, output: 2.00 };
+}
+
+export function estimateCost(inputTokens, outputTokens, model) {
+  const p = getPricing(model);
+  const inputCost = (inputTokens / 1000000) * p.input;
+  const outputCost = (outputTokens / 1000000) * p.output;
+  return inputCost + outputCost;
+}

package/src/utils/files.js

@@ -0,0 +1,46 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export function saveConversation(messages, filename) {
+  const dir = path.join(os.homedir(), '.lumina', 'conversations');
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  const filePath = path.join(dir, filename.endsWith('.json') ? filename : `${filename}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(messages, null, 2), 'utf-8');
+  return filePath;
+}
+
+export function loadConversation(filepath) {
+  try {
+    const raw = fs.readFileSync(filepath, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function detectFileExtension(language) {
+  const extMap = {
+    javascript: 'js', js: 'js', jsx: 'jsx', typescript: 'ts', ts: 'ts',
+    tsx: 'tsx', python: 'py', py: 'py', ruby: 'rb', rb: 'rb',
+    go: 'go', rust: 'rs', rs: 'rs', c: 'c', cpp: 'cpp',
+    java: 'java', kotlin: 'kt', scala: 'scala', swift: 'swift',
+    php: 'php', html: 'html', css: 'css', scss: 'scss', less: 'less',
+    sql: 'sql', sh: 'sh', bash: 'sh', yaml: 'yml', yml: 'yml',
+    json: 'json', xml: 'xml', markdown: 'md', md: 'md',
+  };
+  return extMap[language?.toLowerCase()] || 'txt';
+}
+
+export function writeCodeFile(content, filename) {
+  const cwd = process.cwd();
+  const filePath = path.join(cwd, filename);
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, content, 'utf-8');
+  return filePath;
+}

package/src/utils/tokens.js

@@ -0,0 +1,28 @@
+import { encode } from 'gpt-tokenizer';
+
+export function countTokens(text, model = 'gpt-4o-mini') {
+  if (!text) return 0;
+  try {
+    const tokens = encode(text);
+    return tokens.length;
+  } catch {
+    return approximateTokens(text);
+  }
+}
+
+export function approximateTokens(text) {
+  if (!text) return 0;
+  let count = 0;
+  for (const char of text) {
+    if (/[\x00-\x7F]/.test(char)) {
+      count += 1;
+    } else if (/[\u0080-\u07FF]/.test(char)) {
+      count += 2;
+    } else if (/[\u0800-\uFFFF]/.test(char)) {
+      count += 3;
+    } else {
+      count += 4;
+    }
+  }
+  return Math.ceil(count / 4);
+}