open-jarvis-cli 0.0.0-stage → 1.1.1

package/bin/jarvis.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import * as cfgMod from '../src/config.js';
+import * as memory from '../src/memory.js';
+import { startRepl, ask } from '../src/repl.js';
+import { stats, trySkill } from '../src/skills.js';
+import { runSetup, addKey, changeModel, needsSetup, commandsHelp } from '../src/setup.js';
+import { byId } from '../src/providers.js';
+import { green, dim, red, cyan } from '../src/ui.js';
+
+const pkg = JSON.parse(fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), '../package.json'), 'utf8'));
+const [, , cmd, ...rest] = process.argv;
+
+const USAGE = `
+${green('JARVIS PRO')} v${pkg.version} — AI assistant for your terminal
+${commandsHelp()}
+${cyan('More')}
+  jarvis ask "your question"          one-shot answer
+  jarvis stats                        CPU / RAM / OS
+  jarvis memory                       list remembered facts
+  jarvis config get KEY | unset KEY | path
+
+${cyan('Providers')}
+  ChatGPT · Gemini · OpenRouter · Claude · Grok · Perplexity · Groq · DeepSeek · Mistral · Custom · Ollama
+`;
+
+function handleConfig(args) {
+  const [action, ...tail] = args;
+  if (action === 'set') {
+    let key, value;
+    const joined = tail.join(' ');
+    if (joined.includes('=')) { const i = joined.indexOf('='); key = joined.slice(0, i).trim(); value = joined.slice(i + 1).trim(); }
+    else { key = tail[0]; value = tail.slice(1).join(' '); }
+    if (!key || !value) return console.log(red('Usage: jarvis config set KEY=value'));
+    cfgMod.setValue(key, value);
+    console.log(green('✔ Saved ') + `${key.toUpperCase()} = ${cfgMod.mask(key.toUpperCase(), value)}`);
+  } else if (action === 'get') {
+    const k = (tail[0] || '').toUpperCase();
+    console.log(cfgMod.mask(k, cfgMod.load()[k]));
+  } else if (action === 'unset') {
+    cfgMod.unsetValue(tail[0] || ''); console.log(green('✔ Removed'));
+  } else if (action === 'list') {
+    const c = cfgMod.load();
+    for (const k of cfgMod.KEYS) console.log(`${k.padEnd(12)} ${cfgMod.mask(k, c[k])}`);
+    const saved = Object.entries(cfgMod.raw().profiles || {}).filter(([, v]) => v.key).map(([id]) => byId(id)?.name || id);
+    console.log(`${'SAVED KEYS'.padEnd(12)} ${saved.join(', ') || '(none)'}`);
+  } else if (action === 'path') {
+    console.log(cfgMod.FILE);
+  } else console.log(USAGE);
+}
+
+try {
+  if (!cmd) await startRepl();
+  else if (cmd === 'config') handleConfig(rest);
+  else if (cmd === 'setup' || cmd === 'switch') await runSetup();
+  else if (cmd === 'key') await addKey();
+  else if (cmd === 'model') await changeModel();
+  else if (cmd === 'ask') {
+    const q = rest.join(' ').trim();
+    if (!q) console.log(red('Usage: jarvis ask "question"'));
+    else {
+      let cfg = cfgMod.load();
+      const local = trySkill(q, { title: cfg.TITLE, notify: console.log });
+      if (local !== null) console.log(await local);
+      else {
+        if (process.stdin.isTTY && needsSetup(cfg)) {
+          if (!(await runSetup())) process.exit(0);
+          cfg = cfgMod.load();
+        }
+        await ask({ cfg }, [], q);
+        process.exit(0);
+      }
+    }
+  }
+  else if (cmd === 'stats') console.log(await stats());
+  else if (cmd === 'memory') {
+    const l = memory.all();
+    console.log(l.length ? l.map((x, i) => `${i + 1}. ${x.text}`).join('\n') : 'Memory is empty.');
+  }
+  else if (cmd === '-v' || cmd === '--version') console.log(pkg.version);
+  else console.log(USAGE);
+} catch (e) {
+  console.error(red('✖ ' + e.message));
+  process.exit(1);
+}

package/package.json

@@ -1,6 +1,17 @@
 {
   "name": "open-jarvis-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.1",
+  "description": "JARVIS-style AI assistant for your terminal. BYOK, streaming, free-tier friendly.",
+  "type": "module",
+  "bin": {
+    "jarvis": "bin/jarvis.js",
+    "openjarvispro": "bin/jarvis.js"
+  },
+  "files": ["bin", "src", "README.md"],
+  "engines": { "node": ">=18" },
+  "author": "Rongon Kairy",
+  "repository": { "type": "git", "url": "git+https://github.com/RongonKairy/openjarvispro.git" },
+  "homepage": "https://github.com/RongonKairy",
+  "keywords": ["jarvis", "ai", "cli", "assistant", "terminal"],
+  "license": "MIT"
+}

package/src/config.js

@@ -0,0 +1,89 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { byId } from './providers.js';
+
+export const DIR = path.join(os.homedir(), '.open-jarvis');
+export const FILE = path.join(DIR, 'config.json');
+
+export const DEFAULTS = {
+  AI_API_KEY: '',
+  AI_PROVIDER: 'auto',
+  AI_MODEL: '',
+  TITLE: 'sir',
+  VOICE: 'off',
+  OLLAMA_URL: 'http://localhost:11434',
+  CUSTOM_URL: '',
+};
+export const KEYS = Object.keys(DEFAULTS);
+
+export function raw() {
+  try { return JSON.parse(fs.readFileSync(FILE, 'utf8')); } catch { return {}; }
+}
+function write(obj) {
+  fs.mkdirSync(DIR, { recursive: true });
+  fs.writeFileSync(FILE, JSON.stringify(obj, null, 2), { mode: 0o600 });
+}
+export function update(fn) { const o = raw(); fn(o); write(o); }
+
+/** Effective settings: active provider's saved key/model are resolved into AI_API_KEY / AI_MODEL. */
+export function load() {
+  const s = raw();
+  const cfg = { ...DEFAULTS };
+  for (const k of KEYS) if (s[k] !== undefined) cfg[k] = s[k];
+  const prov = cfg.AI_PROVIDER;
+  const prof = (s.profiles && s.profiles[prov]) || {};
+  cfg.AI_API_KEY = process.env.AI_API_KEY || prof.key || (prov === 'auto' ? s.AI_API_KEY : '') || '';
+  cfg.AI_MODEL = prof.model || s.AI_MODEL || '';
+  cfg.CUSTOM_URL = prof.url || s.CUSTOM_URL || '';
+  return cfg;
+}
+
+/** Save a provider profile and make it the active one. */
+export function saveProfile(id, { key, model, url } = {}) {
+  update((o) => {
+    o.profiles = o.profiles || {};
+    const cur = o.profiles[id] || {};
+    const next = { ...cur };
+    if (key !== undefined) next.key = key;
+    if (model !== undefined) next.model = model;
+    if (url !== undefined) next.url = url;
+    o.profiles[id] = next;
+    o.AI_PROVIDER = id;
+    delete o.AI_MODEL;
+  });
+}
+
+export function setValue(key, value) {
+  key = key.toUpperCase();
+  if (!KEYS.includes(key)) throw new Error(`Unknown key "${key}". Valid keys: ${KEYS.join(', ')}`);
+  if (key === 'AI_PROVIDER' && value !== 'auto' && !byId(value)) throw new Error(`Unknown provider "${value}".`);
+  update((o) => {
+    const p = o.AI_PROVIDER;
+    const explicit = p && p !== 'auto';
+    if (key === 'AI_API_KEY' || key === 'AI_MODEL') {
+      if (explicit) {
+        o.profiles = o.profiles || {};
+        o.profiles[p] = { ...o.profiles[p], [key === 'AI_API_KEY' ? 'key' : 'model']: value };
+      } else o[key] = value;
+    } else if (key === 'AI_PROVIDER') {
+      o.AI_PROVIDER = value;
+      delete o.AI_MODEL;
+    } else o[key] = value;
+  });
+}
+
+export function unsetValue(key) {
+  key = key.toUpperCase();
+  update((o) => {
+    const p = o.AI_PROVIDER;
+    if (p && p !== 'auto' && o.profiles?.[p] && (key === 'AI_API_KEY' || key === 'AI_MODEL')) {
+      delete o.profiles[p][key === 'AI_API_KEY' ? 'key' : 'model'];
+    } else delete o[key];
+  });
+}
+
+export function mask(key, value) {
+  if (key !== 'AI_API_KEY' || !value) return value || '(not set)';
+  return value.length <= 8 ? '****' : value.slice(0, 4) + '…' + value.slice(-4);
+}

package/src/llm.js

@@ -0,0 +1,178 @@
+import { byId } from './providers.js';
+
+export class ApiError extends Error {
+  constructor(msg, { status, kind } = {}) { super(msg); this.status = status; this.kind = kind; }
+}
+
+export function detectProvider(cfg) {
+  if (cfg.AI_PROVIDER && cfg.AI_PROVIDER !== 'auto') return cfg.AI_PROVIDER;
+  const k = cfg.AI_API_KEY || '';
+  if (k.startsWith('sk-ant-')) return 'anthropic';
+  if (k.startsWith('sk-or-')) return 'openrouter';
+  if (k.startsWith('AIza')) return 'gemini';
+  if (k.startsWith('xai-')) return 'xai';
+  if (k.startsWith('pplx-')) return 'perplexity';
+  if (k.startsWith('gsk_')) return 'groq';
+  if (k.startsWith('sk-')) return 'openai';
+  return k ? 'openrouter' : 'ollama';
+}
+
+export function modelFor(cfg, id) {
+  return cfg.AI_MODEL || byId(id)?.models?.[0] || '(set a model)';
+}
+
+function classify(status, text) {
+  if (/credit balance|insufficient|quota|billing|exhausted|exceeded|out of credits|payment/i.test(text) || status === 429 || status === 402) return 'limit';
+  if ([400, 404, 422].includes(status) && /model/i.test(text) && /valid|found|exist|unknown|invalid|support|decommission/i.test(text)) return 'model';
+  if (status === 401 || status === 403) return 'auth';
+  return 'other';
+}
+
+async function* sseData(res) {
+  const dec = new TextDecoder();
+  let buf = '';
+  for await (const chunk of res.body) {
+    buf += dec.decode(chunk, { stream: true });
+    let i;
+    while ((i = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, i).trim();
+      buf = buf.slice(i + 1);
+      if (line.startsWith('data:')) {
+        const d = line.slice(5).trim();
+        if (d && d !== '[DONE]') yield d;
+      }
+    }
+  }
+}
+
+async function* ndjson(res) {
+  const dec = new TextDecoder();
+  let buf = '';
+  for await (const chunk of res.body) {
+    buf += dec.decode(chunk, { stream: true });
+    let i;
+    while ((i = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, i).trim();
+      buf = buf.slice(i + 1);
+      if (line) yield line;
+    }
+  }
+}
+
+async function post(url, headers, body, signal) {
+  let res;
+  try {
+    res = await fetch(url, { method: 'POST', headers: { 'content-type': 'application/json', ...headers }, body: JSON.stringify(body), signal });
+  } catch (e) {
+    throw new ApiError(`fetch failed: ${e.cause?.code || e.message}`, { kind: 'network' });
+  }
+  if (!res.ok) {
+    const txt = (await res.text().catch(() => '')).slice(0, 300);
+    throw new ApiError(`${res.status} ${res.statusText} ${txt}`.trim(), { status: res.status, kind: classify(res.status, txt) });
+  }
+  return res;
+}
+
+async function run(id, cfg, system, history, onToken, signal) {
+  const p = byId(id);
+  if (!p) throw new ApiError(`Unknown provider "${id}". Run: jarvis setup`, { kind: 'other' });
+  const model = modelFor(cfg, id);
+  const key = cfg.AI_API_KEY;
+  let out = '';
+  const emit = (t) => { if (t) { out += t; onToken(t); } };
+
+  if (p.type === 'openai') {
+    let url = p.url;
+    if (p.custom) {
+      if (!cfg.CUSTOM_URL) throw new ApiError('No custom URL set. Run: jarvis setup', { kind: 'other' });
+      url = cfg.CUSTOM_URL.replace(/\/+$/, '') + '/chat/completions';
+    }
+    const res = await post(url, { authorization: `Bearer ${key}` },
+      { model, stream: true, messages: [{ role: 'system', content: system }, ...history] }, signal);
+    for await (const d of sseData(res)) emit(JSON.parse(d).choices?.[0]?.delta?.content);
+  } else if (p.type === 'anthropic') {
+    const res = await post('https://api.anthropic.com/v1/messages',
+      { 'x-api-key': key, 'anthropic-version': '2023-06-01' },
+      { model, max_tokens: 1024, stream: true, system, messages: history }, signal);
+    for await (const d of sseData(res)) {
+      const j = JSON.parse(d);
+      if (j.type === 'content_block_delta') emit(j.delta?.text);
+    }
+  } else if (p.type === 'gemini') {
+    const res = await post(
+      `https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(model)}:streamGenerateContent?alt=sse`,
+      { 'x-goog-api-key': key },
+      {
+        systemInstruction: { parts: [{ text: system }] },
+        contents: history.map((m) => ({ role: m.role === 'assistant' ? 'model' : 'user', parts: [{ text: m.content }] })),
+      }, signal);
+    for await (const d of sseData(res)) emit(JSON.parse(d).candidates?.[0]?.content?.parts?.[0]?.text);
+  } else if (p.type === 'ollama') {
+    const res = await post(`${cfg.OLLAMA_URL.replace(/\/$/, '')}/api/chat`, {},
+      { model, stream: true, messages: [{ role: 'system', content: system }, ...history] }, signal);
+    for await (const l of ndjson(res)) emit(JSON.parse(l).message?.content);
+  }
+  return out;
+}
+
+/** Streams a reply. On network/other errors it falls back to local Ollama; limit/auth errors are surfaced. */
+export async function chat(cfg, system, history, onToken, signal) {
+  const id = detectProvider(cfg);
+  const p = byId(id);
+  if (p && !p.nokey && !cfg.AI_API_KEY) {
+    throw new ApiError('No API key set. Run: jarvis setup', { kind: 'auth' });
+  }
+  try {
+    return await run(id, cfg, system, history, onToken, signal);
+  } catch (err) {
+    if (signal?.aborted || id === 'ollama' || err.kind === 'limit' || err.kind === 'auth' || err.kind === 'model') throw err;
+    try {
+      return await run('ollama', { ...cfg, AI_MODEL: '' }, system, history, onToken, signal);
+    } catch {
+      throw err;
+    }
+  }
+}
+
+/** Ask the provider which models exist right now. Returns an array of ids, or null on any failure. */
+export async function listModels(cfg, id) {
+  const p = byId(id);
+  if (!p) return null;
+  const key = cfg.AI_API_KEY || '';
+  const ctl = new AbortController();
+  const timer = setTimeout(() => ctl.abort(), 6000);
+  try {
+    let url;
+    let headers = {};
+    if (p.type === 'openai') {
+      const chatUrl = p.custom ? (cfg.CUSTOM_URL || '').replace(/\/+$/, '') + '/chat/completions' : p.url;
+      url = chatUrl.replace(/\/chat\/completions$/, '/models');
+      headers = { authorization: `Bearer ${key}` };
+    } else if (p.type === 'anthropic') {
+      url = 'https://api.anthropic.com/v1/models?limit=100';
+      headers = { 'x-api-key': key, 'anthropic-version': '2023-06-01' };
+    } else if (p.type === 'gemini') {
+      url = 'https://generativelanguage.googleapis.com/v1beta/models?pageSize=200';
+      headers = { 'x-goog-api-key': key };
+    } else if (p.type === 'ollama') {
+      url = `${(cfg.OLLAMA_URL || 'http://localhost:11434').replace(/\/$/, '')}/api/tags`;
+    }
+    const res = await fetch(url, { headers, signal: ctl.signal });
+    if (!res.ok) return null;
+    const j = await res.json();
+    let ids;
+    if (p.type === 'gemini') {
+      ids = (j.models || []).filter((m) => (m.supportedGenerationMethods || []).includes('generateContent')).map((m) => m.name.replace(/^models\//, ''));
+    } else if (p.type === 'ollama') ids = (j.models || []).map((m) => m.name);
+    else ids = (j.data || []).map((m) => m.id);
+    ids = [...new Set(ids)].filter(Boolean);
+    if (id === 'openai') ids = ids.filter((m) => /^(gpt|o\d|chatgpt)/.test(m) && !/audio|realtime|transcribe|tts|image|embedding|moderation|search/.test(m));
+    if (id === 'openrouter') ids.sort((a, b) => (Number(b.endsWith(':free')) - Number(a.endsWith(':free'))) || a.localeCompare(b));
+    else ids.sort();
+    return ids.length ? ids : null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/memory.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { DIR } from './config.js';
+
+const FILE = path.join(DIR, 'memory.json');
+
+function read() {
+  try { return JSON.parse(fs.readFileSync(FILE, 'utf8')); } catch { return []; }
+}
+function write(list) {
+  fs.mkdirSync(DIR, { recursive: true });
+  fs.writeFileSync(FILE, JSON.stringify(list, null, 2));
+}
+
+export const all = read;
+export function add(text) {
+  const list = read();
+  list.push({ text, at: new Date().toISOString() });
+  write(list.slice(-200));
+}
+export function remove(n) {
+  const list = read();
+  if (n < 1 || n > list.length) return false;
+  list.splice(n - 1, 1);
+  write(list);
+  return true;
+}
+export function clear() { write([]); }

package/src/menu.js

@@ -0,0 +1,86 @@
+import readline from 'node:readline';
+import { green, dim, cyan } from './ui.js';
+
+/** Temporarily take over keyboard input (works even while a readline prompt exists). */
+function takeover(handler) {
+  const stdin = process.stdin;
+  readline.emitKeypressEvents(stdin);
+  const saved = stdin.listeners('keypress');
+  stdin.removeAllListeners('keypress');
+  const wasRaw = stdin.isRaw;
+  const wasPaused = stdin.isPaused();
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.on('keypress', handler);
+  return () => {
+    stdin.removeListener('keypress', handler);
+    for (const l of saved) stdin.on('keypress', l);
+    if (!wasRaw) stdin.setRawMode(false);
+    if (wasPaused) stdin.pause();
+  };
+}
+
+/** Arrow-key menu. Returns the chosen item, or null if cancelled. */
+export function select(title, items, { initial = 0 } = {}) {
+  return new Promise((resolve) => {
+    const out = process.stdout;
+    if (!process.stdin.isTTY || !items.length) return resolve(null);
+    const n = items.length;
+    let idx = Math.min(Math.max(initial, 0), n - 1);
+    const page = Math.max(4, Math.min(n, (out.rows || 24) - 5));
+    let drawn = 0;
+    let restore = () => {};
+
+    const render = () => {
+      if (drawn) out.write(`\x1b[${drawn}A`);
+      const start = Math.max(0, Math.min(idx - Math.floor(page / 2), n - page));
+      const lines = [cyan(title), dim('  ↑/↓ move · Enter select · Esc cancel')];
+      for (let i = start; i < start + page && i < n; i++) {
+        const it = items[i];
+        const hint = it.hint ? dim('  ' + it.hint) : '';
+        lines.push(i === idx ? green(`  ❯ ${it.label}`) + hint : `    ${it.label}` + hint);
+      }
+      while (lines.length < 2 + page) lines.push('');
+      for (const l of lines) out.write('\x1b[2K' + l + '\n');
+      drawn = lines.length;
+    };
+
+    const finish = (val) => {
+      restore();
+      out.write(`\x1b[${drawn}A\x1b[0J\x1b[?25h`);
+      if (val) out.write(green('✔ ') + dim(title + '  ') + val.label + '\n');
+      resolve(val);
+    };
+
+    out.write('\x1b[?25l');
+    restore = takeover((str, key = {}) => {
+      if (key.ctrl && key.name === 'c') { restore(); out.write('\x1b[?25h\n'); process.exit(130); }
+      if (key.name === 'up' || key.name === 'k') { idx = (idx - 1 + n) % n; render(); }
+      else if (key.name === 'down' || key.name === 'j') { idx = (idx + 1) % n; render(); }
+      else if (key.name === 'return' || key.name === 'enter') finish(items[idx]);
+      else if (key.name === 'escape') finish(null);
+      else if (/^[1-9]$/.test(str || '') && Number(str) <= n) { idx = Number(str) - 1; render(); }
+    });
+    render();
+  });
+}
+
+/** Single-line input. secret=true masks what you type. Returns string or null if cancelled. */
+export function lineInput(prompt, { secret = false, def = '' } = {}) {
+  return new Promise((resolve) => {
+    const out = process.stdout;
+    if (!process.stdin.isTTY) return resolve(null);
+    let buf = '';
+    out.write(prompt);
+    const restore = takeover((str, key = {}) => {
+      if (key.ctrl && key.name === 'c') { restore(); out.write('\n'); process.exit(130); }
+      if (key.name === 'escape') { restore(); out.write('\n'); return resolve(null); }
+      if (key.name === 'return' || key.name === 'enter') { restore(); out.write('\n'); return resolve((buf || def).trim()); }
+      if (key.name === 'backspace') { if (buf.length) { buf = buf.slice(0, -1); out.write('\b \b'); } return; }
+      if (str && !key.ctrl && !key.meta && str >= ' ') {
+        buf += str;
+        out.write(secret ? '•'.repeat(str.length) : str);
+      }
+    });
+  });
+}

package/src/providers.js

@@ -0,0 +1,35 @@
+// Every provider the setup wizard can offer. "openai" type = OpenAI-compatible chat API.
+export const PROVIDERS = [
+  { id: 'openai', name: 'ChatGPT (OpenAI)', type: 'openai', hint: 'paid',
+    url: 'https://api.openai.com/v1/chat/completions', keyUrl: 'https://platform.openai.com/api-keys',
+    models: ['gpt-4o-mini', 'gpt-4o', 'gpt-4.1'] },
+  { id: 'gemini', name: 'Gemini (Google)', type: 'gemini', hint: 'free tier available',
+    keyUrl: 'https://aistudio.google.com/apikey',
+    models: ['gemini-2.5-flash', 'gemini-2.5-pro', 'gemini-2.0-flash'] },
+  { id: 'openrouter', name: 'OpenRouter (hundreds of models)', type: 'openai', hint: 'has free models',
+    url: 'https://openrouter.ai/api/v1/chat/completions', keyUrl: 'https://openrouter.ai/keys',
+    models: ['meta-llama/llama-3.3-70b-instruct:free', 'openai/gpt-4o-mini', 'google/gemini-2.5-flash'] },
+  { id: 'anthropic', name: 'Claude (Anthropic)', type: 'anthropic', hint: 'paid',
+    keyUrl: 'https://console.anthropic.com/settings/keys',
+    models: ['claude-haiku-5-5', 'claude-sonnet-5-5', 'claude-opus-5-5'] },
+  { id: 'xai', name: 'Grok (xAI)', type: 'openai', hint: 'paid',
+    url: 'https://api.x.ai/v1/chat/completions', keyUrl: 'https://console.x.ai',
+    models: ['grok-3-mini', 'grok-3', 'grok-4'] },
+  { id: 'perplexity', name: 'Perplexity', type: 'openai', hint: 'web-search answers',
+    url: 'https://api.perplexity.ai/chat/completions', keyUrl: 'https://www.perplexity.ai/settings/api',
+    models: ['sonar', 'sonar-pro', 'sonar-reasoning-pro'] },
+  { id: 'groq', name: 'Groq (very fast)', type: 'openai', hint: 'free tier available',
+    url: 'https://api.groq.com/openai/v1/chat/completions', keyUrl: 'https://console.groq.com/keys',
+    models: ['llama-3.3-70b-versatile', 'llama-3.1-8b-instant'] },
+  { id: 'deepseek', name: 'DeepSeek', type: 'openai', hint: 'cheap',
+    url: 'https://api.deepseek.com/chat/completions', keyUrl: 'https://platform.deepseek.com/api_keys',
+    models: ['deepseek-chat', 'deepseek-reasoner'] },
+  { id: 'mistral', name: 'Mistral', type: 'openai', hint: 'free tier available',
+    url: 'https://api.mistral.ai/v1/chat/completions', keyUrl: 'https://console.mistral.ai/api-keys',
+    models: ['mistral-small-latest', 'mistral-large-latest'] },
+  { id: 'custom', name: 'Custom (any OpenAI-compatible API)', type: 'openai', custom: true, hint: 'you give the URL', models: [] },
+  { id: 'ollama', name: 'Ollama (local, free, no key)', type: 'ollama', nokey: true, hint: 'runs on your PC',
+    models: ['llama3.2', 'qwen2.5', 'mistral'] },
+];
+
+export const byId = (id) => PROVIDERS.find((p) => p.id === id);

package/src/repl.js

@@ -0,0 +1,185 @@
+import readline from 'node:readline';
+import os from 'node:os';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import * as cfgMod from './config.js';
+import * as memory from './memory.js';
+import { chat, detectProvider, modelFor } from './llm.js';
+import { byId } from './providers.js';
+import { trySkill, HELP } from './skills.js';
+import { speak, stopSpeaking } from './voice.js';
+import { runSetup, addKey, needsSetup, changeModel } from './setup.js';
+import { select } from './menu.js';
+import { banner, spinner, green, cyan, dim, red, amber } from './ui.js';
+
+const VERSION = JSON.parse(fs.readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), '../package.json'), 'utf8')).version;
+
+export function buildSystem(cfg) {
+  const facts = memory.all().map((m) => `- ${m.text}`).join('\n') || '(none)';
+  return `You are JARVIS, a personal AI assistant living in the user's terminal, inspired by Iron Man's J.A.R.V.I.S.
+Personality: calm, witty, polite, slightly sarcastic British butler. Address the user as "${cfg.TITLE}".
+Keep answers concise and terminal-friendly (short paragraphs, plain text, minimal markdown). Reply in the language the user writes in.
+Current time: ${new Date().toString()}. OS: ${os.type()} ${os.release()}.
+Things the user asked you to remember:
+${facts}`;
+}
+
+function friendly(e) {
+  const m = String(e.message || e);
+  if (e.kind === 'auth') return 'The API key was rejected or missing.';
+  if (e.kind === 'limit') return 'Limit reached (credits/quota or rate limit).';
+  if (e.kind === 'model') return 'This model name is not valid for the selected provider.';
+  if (/fetch failed|ENOTFOUND|ECONN/i.test(m)) return 'Cannot reach the network (or Ollama is not running).';
+  return m;
+}
+
+async function tryOnce(cfg, history, text) {
+  history.push({ role: 'user', content: text });
+  const stop = spinner();
+  let first = true;
+  try {
+    const reply = await chat(cfg, buildSystem(cfg), history.slice(-20), (tok) => {
+      if (first) { stop(); process.stdout.write(green('JARVIS ❯ ')); first = false; }
+      process.stdout.write(tok);
+    });
+    if (first) stop();
+    process.stdout.write('\n');
+    history.push({ role: 'assistant', content: reply });
+    if (cfg.VOICE === 'on') speak(reply);
+    return { ok: true, reply };
+  } catch (err) {
+    if (first) stop(); else process.stdout.write('\n');
+    history.pop();
+    return { ok: false, err };
+  }
+}
+
+/** When the API limit is over (or the key is bad): offer a new key / another provider. */
+async function recover(err, S) {
+  const id = detectProvider(S.cfg);
+  const name = byId(id)?.name || id;
+  const model = err.kind === 'model';
+  console.log(amber(model ? `⚠ ${name}: model "${modelFor(S.cfg, id)}" is not valid.`
+    : err.kind === 'limit' ? `⚠ ${name}: limit reached.` : `⚠ ${name}: API key problem.`));
+  const options = [];
+  if (model) options.push({ label: 'Pick a different model', value: 'model', hint: 'command: jarvis model' });
+  else options.push({ label: `Add a NEW API key for ${name}`, value: 'key', hint: 'command: jarvis key' });
+  options.push({ label: 'Switch to another provider', value: 'setup', hint: 'command: jarvis setup' });
+  if (!model) options.push({ label: 'Retry the same message', value: 'retry' });
+  options.push({ label: 'Cancel', value: 'cancel' });
+  const c = await select('What would you like to do?', options);
+  if (!c || c.value === 'cancel') return false;
+  if (c.value === 'key' && !(await addKey())) return false;
+  if (c.value === 'model' && !(await changeModel())) return false;
+  if (c.value === 'setup' && !(await runSetup())) return false;
+  S.cfg = cfgMod.load();
+  return true;
+}
+
+/** S = { cfg } so the config can be refreshed after the user adds a key. */
+export async function ask(S, history, text) {
+  for (;;) {
+    const res = await tryOnce(S.cfg, history, text);
+    if (res.ok) return res.reply;
+    console.log(red(`✖ ${friendly(res.err)}`));
+    const k = res.err.kind;
+    if (k === 'limit' || k === 'auth' || k === 'model') {
+      console.log(dim(String(res.err.message).slice(0, 160)));
+      if (!process.stdin.isTTY) {
+        console.log(dim('Add a new key with:  jarvis key   (or)   jarvis config set AI_API_KEY=your_key'));
+        return null;
+      }
+      if (await recover(res.err, S)) continue;
+    }
+    return null;
+  }
+}
+
+export async function startRepl() {
+  let cfg = cfgMod.load();
+
+  if (process.stdin.isTTY && needsSetup(cfg)) {
+    console.log('\n' + green('  JARVIS PRO') + dim('  ·  first-time setup'));
+    console.log(dim('  Pick the AI you want to use. Use ↑ ↓ and Enter.\n'));
+    if (!(await runSetup())) {
+      console.log(dim('\nSetup cancelled. Run  jarvis setup  whenever you are ready.'));
+      process.exit(0);
+    }
+    cfg = cfgMod.load();
+  }
+
+  const S = { cfg };
+  const showBanner = () => {
+    const id = detectProvider(S.cfg);
+    banner({
+      tool: `OpenJarvisPro v${VERSION}`,
+      agent: `${byId(id)?.name || id} · ${modelFor(S.cfg, id)}`,
+      key: S.cfg.AI_API_KEY ? cfgMod.mask('AI_API_KEY', S.cfg.AI_API_KEY) : (byId(id)?.nokey ? dim('not needed') : red('not set')),
+    });
+  };
+  showBanner();
+  if (!S.cfg.AI_API_KEY && !byId(detectProvider(S.cfg))?.nokey) {
+    console.log(amber('⚠ No API key yet. Run:  jarvis setup') + '\n' + dim('  (Skills like open/weather/timer/stats work without a key.)\n'));
+  }
+
+  const history = [];
+  const hr = new Date().getHours();
+  const greet = hr < 12 ? 'Good morning' : hr < 18 ? 'Good afternoon' : 'Good evening';
+  console.log(green('JARVIS ❯ ') + `${greet}, ${S.cfg.TITLE}. At your service.\n`);
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: cyan('you ❯ ') });
+  const ctx = {
+    get title() { return S.cfg.TITLE; },
+    notify: (msg) => { process.stdout.write(`\n${msg}\x07\n`); rl.prompt(true); if (S.cfg.VOICE === 'on') speak(msg); },
+  };
+
+  rl.prompt();
+  rl.on('line', async (line) => {
+    const text = line.trim();
+    if (!text) return rl.prompt();
+    rl.pause();
+    try {
+      stopSpeaking();
+      if (text.startsWith('/')) {
+        const [cmd, arg] = text.slice(1).split(/\s+/);
+        if (cmd === 'exit' || cmd === 'quit') return rl.close();
+        else if (cmd === 'help') console.log(HELP);
+        else if (cmd === 'clear') { history.length = 0; console.log(dim('Conversation cleared.')); }
+        else if (cmd === 'voice') {
+          cfgMod.setValue('VOICE', arg === 'on' ? 'on' : 'off');
+          S.cfg = cfgMod.load();
+          console.log(dim(`Voice ${S.cfg.VOICE}.`));
+        } else if (cmd === 'model') {
+          const id = detectProvider(S.cfg);
+          console.log(`${byId(id)?.name || id} / ${modelFor(S.cfg, id)}`);
+          if (await changeModel()) S.cfg = cfgMod.load();
+        } else if (cmd === 'setup' || cmd === 'switch') {
+          if (await runSetup()) { S.cfg = cfgMod.load(); history.length = 0; }
+        } else if (cmd === 'key') {
+          if (await addKey()) S.cfg = cfgMod.load();
+        } else console.log(dim('Unknown command. Try /help'));
+      } else {
+        const local = trySkill(text, ctx);
+        if (local !== null) {
+          const out = await local;
+          console.log(green('JARVIS ❯ ') + out);
+          if (S.cfg.VOICE === 'on' && typeof out === 'string') speak(out);
+        } else {
+          await ask(S, history, text);
+        }
+      }
+    } catch (e) {
+      console.log(red(`✖ ${e.message}`));
+    }
+    console.log();
+    rl.resume();
+    rl.prompt();
+  });
+
+  rl.on('close', () => {
+    stopSpeaking();
+    console.log(`\n${green('JARVIS ❯ ')}Goodbye, ${S.cfg.TITLE}.`);
+    process.exit(0);
+  });
+}

package/src/setup.js

@@ -0,0 +1,129 @@
+import * as cfgMod from './config.js';
+import { PROVIDERS, byId } from './providers.js';
+import { detectProvider, listModels } from './llm.js';
+import { select, lineInput } from './menu.js';
+import { green, dim, cyan, red } from './ui.js';
+
+export function commandsHelp() {
+  return `
+${cyan('Handy commands')}
+  ${green('jarvis')}                              start chatting
+  ${green('jarvis setup')}                        change provider / model  ${dim('(↑ ↓ + Enter)')}
+  ${green('jarvis model')}                        pick a different model of the same provider
+  ${green('jarvis key')}                          add a NEW API key  ${dim('(when your limit is over)')}
+  ${green('jarvis config set AI_API_KEY=')}${dim('your_key')}   same thing, one line
+  ${green('jarvis config list')}                  show current settings
+  ${dim('inside chat:')} /setup  /key  /model  /help  /exit
+`;
+}
+
+export function needsSetup(cfg) {
+  const p = cfgMod.raw().AI_PROVIDER;
+  return (!p || p === 'auto') && !cfg.AI_API_KEY;
+}
+
+const clean = (k) => (k || '').replace(/^["']|["']$/g, '').trim();
+
+/** Full wizard: provider → key → model. Returns true when saved. */
+export async function runSetup() {
+  if (!process.stdin.isTTY) {
+    console.log(red('Setup needs an interactive terminal. Run: jarvis setup'));
+    return false;
+  }
+  const s = cfgMod.raw();
+  const profiles = s.profiles || {};
+  const items = PROVIDERS.map((p) => ({
+    label: p.name, value: p,
+    hint: [profiles[p.id]?.key ? '✓ key saved' : '', p.hint || ''].filter(Boolean).join(' · '),
+  }));
+  const pick = await select('Choose your AI provider', items,
+    { initial: Math.max(0, PROVIDERS.findIndex((p) => p.id === s.AI_PROVIDER)) });
+  if (!pick) return false;
+  const p = pick.value;
+  const prof = { ...(profiles[p.id] || {}) };
+
+  if (p.custom) {
+    const url = await lineInput(`Base URL ${dim('(e.g. https://api.example.com/v1)')}: `, { def: prof.url || '' });
+    if (!url) return false;
+    prof.url = url.replace(/\/+$/, '');
+  }
+
+  if (!p.nokey) {
+    let key = prof.key;
+    if (key) {
+      const c = await select(`API key for ${p.name}`, [
+        { label: `Use saved key (${cfgMod.mask('AI_API_KEY', key)})`, value: 'use' },
+        { label: 'Enter a new API key', value: 'new' },
+      ]);
+      if (!c) return false;
+      if (c.value === 'new') key = '';
+    }
+    if (!key) {
+      if (p.keyUrl) console.log(dim(`  Get a key here: ${p.keyUrl}`));
+      key = clean(await lineInput('Paste your API key (hidden): ', { secret: true }));
+      if (!key) { console.log(red('No key entered. Cancelled.')); return false; }
+    }
+    prof.key = key;
+  }
+
+  const model = await pickModel(p, { ...cfgMod.load(), AI_API_KEY: prof.key || '', CUSTOM_URL: prof.url || '' });
+  if (!model) return false;
+
+  cfgMod.saveProfile(p.id, { key: prof.key, model, url: prof.url });
+  console.log(`\n${green('✔ Ready:')} ${p.name} · ${model}`);
+  if (p.id === 'ollama') console.log(dim('  Make sure Ollama is running:  ollama serve   (and  ollama pull ' + model + ')'));
+  console.log(commandsHelp());
+  return true;
+}
+
+/** Add / replace the API key of the current provider (use when the old one hit its limit). */
+export async function addKey() {
+  const cfg = cfgMod.load();
+  const id = detectProvider(cfg);
+  const p = byId(id);
+  if (!process.stdin.isTTY) { console.log(red('Run this in an interactive terminal, or use: jarvis config set AI_API_KEY=your_key')); return false; }
+  if (!p || p.nokey) { console.log(dim('This provider needs no key. Run  jarvis setup  to choose another.')); return false; }
+  console.log(dim(`  New key for ${p.name}${p.keyUrl ? '  ·  get one: ' + p.keyUrl : ''}`));
+  const key = clean(await lineInput('Paste NEW API key (hidden): ', { secret: true }));
+  if (!key) { console.log(red('No key entered. Cancelled.')); return false; }
+  cfgMod.saveProfile(id, { key });
+  console.log(green('✔ New key saved ') + dim(`(${cfgMod.mask('AI_API_KEY', key)})`));
+  return true;
+}
+
+/** Model picker: loads the provider's live model list; falls back to common models. Returns id or null. */
+export async function pickModel(p, cfgLike) {
+  process.stdout.write(dim('  Loading available models…'));
+  const live = await listModels(cfgLike, p.id);
+  process.stdout.write('\r\x1b[2K');
+  const curated = p.models || [];
+  if (!live && curated.length) console.log(dim('  (could not load the live model list — showing common models)'));
+  const list = live || curated;
+  const custom = { label: '✎ Type a model name…', value: '__custom' };
+  const items = list.map((m) => ({ label: m, value: m, hint: m.endsWith(':free') ? 'free' : m === curated[0] ? 'recommended' : '' }));
+  if (list.length > 12) items.unshift(custom); else items.push(custom);
+  const pick = items.length > 1
+    ? await select(`Choose a model for ${p.name}${live ? '  (live list)' : ''}`, items, { initial: list.length > 12 ? 1 : 0 })
+    : custom;
+  if (!pick) return null;
+  if (pick.value === '__custom') {
+    const m = await lineInput('Model name: ');
+    if (!m) { console.log(red('No model entered.')); return null; }
+    return m;
+  }
+  return pick.value;
+}
+
+/** Change only the model of the current provider (keeps the key). */
+export async function changeModel() {
+  const cfg = cfgMod.load();
+  const id = detectProvider(cfg);
+  const p = byId(id);
+  if (!process.stdin.isTTY) { console.log(red('Run this in an interactive terminal, or use: jarvis config set AI_MODEL=model-name')); return false; }
+  if (!p) return false;
+  const model = await pickModel(p, cfg);
+  if (!model) return false;
+  cfgMod.saveProfile(id, { model });
+  console.log(green('✔ Model set: ') + model);
+  return true;
+}

package/src/skills.js

@@ -0,0 +1,130 @@
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+import * as memory from './memory.js';
+import { bar, green, dim, cyan } from './ui.js';
+
+const SITES = {
+  youtube: 'https://www.youtube.com', google: 'https://www.google.com',
+  github: 'https://github.com', gmail: 'https://mail.google.com',
+  facebook: 'https://www.facebook.com', chatgpt: 'https://chatgpt.com',
+  claude: 'https://claude.ai', whatsapp: 'https://web.whatsapp.com',
+  netflix: 'https://www.netflix.com', spotify: 'https://open.spotify.com',
+};
+
+function launch(target, isUrl) {
+  const p = process.platform;
+  let cmd, args;
+  if (p === 'win32') { cmd = 'cmd'; args = ['/c', 'start', '', target]; }
+  else if (p === 'darwin') { cmd = 'open'; args = isUrl ? [target] : ['-a', target]; }
+  else { cmd = isUrl ? 'xdg-open' : target; args = isUrl ? [target] : []; }
+  const child = spawn(cmd, args, { detached: true, stdio: 'ignore', windowsHide: true });
+  child.on('error', () => {});
+  child.unref();
+}
+
+export function openThing(name) {
+  const clean = name.trim();
+  if (!/^[\w .:/?=#%@+-]{1,200}$/.test(clean)) return false;
+  const site = SITES[clean.toLowerCase()];
+  if (site) { launch(site, true); return `Opening ${clean}.`; }
+  if (/^https?:\/\//i.test(clean)) { launch(clean, true); return `Opening ${clean}.`; }
+  if (/^[\w-]+(\.[\w-]+)+(\/\S*)?$/.test(clean)) { launch('https://' + clean, true); return `Opening ${clean}.`; }
+  launch(clean, false);
+  return `Launching ${clean}.`;
+}
+
+async function cpuPercent() {
+  const snap = () => os.cpus().reduce((a, c) => {
+    const t = Object.values(c.times).reduce((x, y) => x + y, 0);
+    return { idle: a.idle + c.times.idle, total: a.total + t };
+  }, { idle: 0, total: 0 });
+  const a = snap();
+  await new Promise((r) => setTimeout(r, 400));
+  const b = snap();
+  const total = b.total - a.total;
+  return total ? 100 - ((b.idle - a.idle) / total) * 100 : 0;
+}
+
+export async function stats() {
+  const cpu = await cpuPercent();
+  const total = os.totalmem(), used = total - os.freemem();
+  const gb = (n) => (n / 1024 ** 3).toFixed(1);
+  const up = os.uptime();
+  return [
+    cyan('SYSTEM STATUS'),
+    `  CPU  ${bar(cpu)}   ${os.cpus().length} cores`,
+    `  RAM  ${bar((used / total) * 100)}   ${gb(used)} / ${gb(total)} GB`,
+    `  OS   ${os.type()} ${os.release()}  (${os.arch()})`,
+    `  UP   ${Math.floor(up / 3600)}h ${Math.floor((up % 3600) / 60)}m`,
+  ].join('\n');
+}
+
+const UNITS = { second: 1, sec: 1, minute: 60, min: 60, hour: 3600, hr: 3600 };
+
+/**
+ * Local skills: handled without calling the LLM.
+ * Returns a string (or promise of string) when handled, otherwise null.
+ */
+export function trySkill(input, ctx) {
+  const t = input.trim();
+  let m;
+
+  if (/^(what('| i)?s )?(the )?(time|date)\b/i.test(t) || /^time\??$/i.test(t))
+    return new Date().toLocaleString();
+
+  if (/^(system )?(stats|status)$/i.test(t) || /\b(cpu|ram)\b.*\b(usage|status)\b/i.test(t)) return stats();
+
+  if ((m = t.match(/^remember(?: that)?\s+(.+)/i))) {
+    memory.add(m[1]);
+    return `Noted, ${ctx.title}. I shall remember: "${m[1]}"`;
+  }
+  if (/^what do you (remember|know about me)/i.test(t) || /^memory$/i.test(t)) {
+    const list = memory.all();
+    return list.length ? list.map((x, i) => `${i + 1}. ${x.text}`).join('\n') : 'My memory banks are empty, sir.';
+  }
+  if ((m = t.match(/^forget\s+#?(\d+)$/i))) {
+    return memory.remove(Number(m[1])) ? 'Done. Forgotten.' : 'No such memory number.';
+  }
+  if (/^forget (everything|all)$/i.test(t)) { memory.clear(); return 'Memory wiped.'; }
+
+  if ((m = t.match(/^(?:open|launch|start)\s+(.+)/i))) return openThing(m[1]) || 'I would rather not run that, sir.';
+
+  if ((m = t.match(/^(?:calc(?:ulate)?|math)\s+(.+)/i))) {
+    const expr = m[1].replace(/\^/g, '**');
+    if (!/^[\d+\-*/().%\s]+$/.test(expr)) return 'Numbers and + - * / ( ) % only, please.';
+    try { return `= ${Function(`"use strict"; return (${expr})`)()}`; } catch { return 'That does not compute.'; }
+  }
+
+  if ((m = t.match(/^weather(?: in| of| for)?\s*(.*)$/i))) {
+    const city = m[1].trim();
+    return fetch(`https://wttr.in/${encodeURIComponent(city)}?format=3`)
+      .then((r) => r.text()).then((s) => s.trim()).catch(() => 'Unable to reach the weather service.');
+  }
+
+  if ((m = t.match(/^(?:set (?:a )?)?(?:timer|remind me)(?: in| for)?\s+(\d+)\s*(seconds?|secs?|minutes?|mins?|hours?|hrs?)(?:\s+(?:to|about)\s+(.+))?$/i))) {
+    const secs = Number(m[1]) * UNITS[m[2].toLowerCase().replace(/s$/, '')];
+    const what = m[3] || 'Timer finished';
+    setTimeout(() => ctx.notify(`⏰ ${what}`), secs * 1000).unref?.();
+    return `Timer set for ${m[1]} ${m[2]}.`;
+  }
+
+  return null;
+}
+
+export const HELP = `
+${green('Chat')}     just type anything and press Enter
+${green('Skills')}   ${dim('(no API call needed)')}
+  open youtube | open notepad | open github.com
+  weather <city>            time
+  stats                     calculate 12*(3+4)
+  remember that <fact>      what do you remember
+  forget <number>           forget all
+  timer 5 minutes           remind me in 10 minutes to stretch
+${green('Slash')}
+  /voice on|off   speak replies aloud
+  /clear          reset conversation
+  /model          show current model and pick another
+  /setup          change provider / model (arrow keys)
+  /key            add a NEW API key
+  /help  /exit
+`;

package/src/ui.js

@@ -0,0 +1,71 @@
+const c = (r, g, b) => (s) => `\x1b[38;2;${r};${g};${b}m${s}\x1b[0m`;
+export const green = c(0, 255, 170);
+export const cyan = c(0, 220, 255);
+export const dim = c(110, 140, 130);
+export const red = c(255, 80, 100);
+export const amber = c(255, 190, 50);
+export const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+
+const JARVIS = [
+  '     ██╗ █████╗ ██████╗ ██╗   ██╗██╗███████╗',
+  '     ██║██╔══██╗██╔══██╗██║   ██║██║██╔════╝',
+  '     ██║███████║██████╔╝██║   ██║██║███████╗',
+  '██   ██║██╔══██║██╔══██╗╚██╗ ██╔╝██║╚════██║',
+  '╚█████╔╝██║  ██║██║  ██║ ╚████╔╝ ██║███████║',
+  ' ╚════╝ ╚═╝  ╚═╝╚═╝  ╚═╝  ╚═══╝  ╚═╝╚══════╝',
+];
+const PRO = [
+  '██████╗ ██████╗  ██████╗ ',
+  '██╔══██╗██╔══██╗██╔═══██╗',
+  '██████╔╝██████╔╝██║   ██║',
+  '██╔═══╝ ██╔══██╗██║   ██║',
+  '██║     ██║  ██║╚██████╔╝',
+  '╚═╝     ╚═╝  ╚═╝ ╚═════╝ ',
+];
+
+export const CREDIT = {
+  name: 'Rongon Kairy',
+  github: 'https://github.com/RongonKairy',
+};
+
+const blue = c(60, 150, 255);
+const purple = c(170, 70, 200);
+const gray = c(150, 150, 150);
+
+/** info = { tool, agent, key } */
+export function printLogo() {
+  const wide = (process.stdout.columns || 80) >= 74;
+  const logo = JARVIS.map((l, i) => (wide ? l.padEnd(45) + PRO[i] : l));
+  console.log('\n' + logo.map((l) => green(l)).join('\n') + '\n');
+}
+
+export function banner(info) {
+  printLogo();
+  const tag = (label, col) => col(`[ ${label} ]`);
+  console.log(` ${tag('NEURAL CORE ONLINE', blue)}`);
+  console.log(` ${tag('TOOL ', purple)}  ${info.tool}`);
+  console.log(` ${tag('AGENT', purple)}  ${info.agent}`);
+  console.log(` ${tag('KEY  ', purple)}  ${info.key}`);
+  console.log(` ${tag('EXIT ', gray)}  Press ${red('Ctrl + C')} or type ${red('/exit')} to stop`);
+  const rule = '='.repeat(58);
+  console.log(rule);
+  console.log(` ${blue('CREATED BY')}  ${CREDIT.name}`);
+  console.log(` ${blue('GITHUB    ')}  ${CREDIT.github}`);
+  console.log(rule);
+  console.log(dim(' Type /help for commands.\n'));
+}
+
+export function spinner(label = 'thinking') {
+  const frames = '⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏';
+  let i = 0;
+  const t = setInterval(() => {
+    process.stdout.write(`\r${green(frames[i++ % frames.length])} ${dim(label)}   `);
+  }, 80);
+  return () => { clearInterval(t); process.stdout.write('\r\x1b[2K'); };
+}
+
+export function bar(pct, width = 20) {
+  const filled = Math.round((pct / 100) * width);
+  const col = pct > 85 ? red : pct > 65 ? amber : green;
+  return col('█'.repeat(filled)) + dim('░'.repeat(width - filled)) + ` ${pct.toFixed(0)}%`;
+}

package/src/voice.js

@@ -0,0 +1,27 @@
+import { spawn } from 'node:child_process';
+
+let current = null;
+
+export function stopSpeaking() {
+  if (current) { try { current.kill(); } catch {} current = null; }
+}
+
+export function speak(text) {
+  stopSpeaking();
+  const clean = text.replace(/[`*_#>]/g, '').replace(/\s+/g, ' ').trim().slice(0, 1500);
+  if (!clean) return;
+  const env = { ...process.env, JARVIS_TEXT: clean };
+  let p;
+  if (process.platform === 'win32') {
+    p = spawn('powershell', ['-NoProfile', '-Command',
+      'Add-Type -AssemblyName System.Speech; $s = New-Object System.Speech.Synthesis.SpeechSynthesizer; $s.Speak($env:JARVIS_TEXT)'],
+      { env, stdio: 'ignore', windowsHide: true });
+  } else if (process.platform === 'darwin') {
+    p = spawn('say', [clean], { stdio: 'ignore' });
+  } else {
+    p = spawn('espeak-ng', [clean], { stdio: 'ignore' });
+  }
+  p.on('error', () => {});
+  p.on('exit', () => { if (current === p) current = null; });
+  current = p;
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.