@usejarvis/brain 0.1.0

package/src/cli/doctor.ts

@@ -0,0 +1,230 @@
+/**
+ * J.A.R.V.I.S. Doctor — Environment Diagnostics
+ *
+ * Checks system requirements, configuration, and connectivity.
+ */
+
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { existsSync, readFileSync } from 'node:fs';
+import {
+  c, printBanner, printOk, printWarn, printErr, printInfo, startSpinner, closeRL,
+} from './helpers.ts';
+
+const JARVIS_DIR = join(homedir(), '.jarvis');
+const CONFIG_PATH = join(JARVIS_DIR, 'config.yaml');
+
+interface CheckResult {
+  name: string;
+  status: 'ok' | 'warn' | 'fail' | 'skip';
+  message: string;
+}
+
+export async function runDoctor(): Promise<void> {
+  printBanner();
+  console.log(c.bold('Running system diagnostics...\n'));
+
+  const results: CheckResult[] = [];
+
+  // ── Check 1: Bun Version ──────────────────────────────────────────
+
+  const bunVersion = Bun.version;
+  const [major] = bunVersion.split('.').map(Number);
+  if (major! >= 1) {
+    results.push({ name: 'Bun Runtime', status: 'ok', message: `v${bunVersion}` });
+  } else {
+    results.push({ name: 'Bun Runtime', status: 'warn', message: `v${bunVersion} (>= 1.0.0 recommended)` });
+  }
+
+  // ── Check 2: Data Directory ───────────────────────────────────────
+
+  if (existsSync(JARVIS_DIR)) {
+    results.push({ name: 'Data Directory', status: 'ok', message: JARVIS_DIR });
+  } else {
+    results.push({ name: 'Data Directory', status: 'warn', message: `${JARVIS_DIR} not found. Run: jarvis onboard` });
+  }
+
+  // ── Check 3: Config File ──────────────────────────────────────────
+
+  let config: any = null;
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      const YAML = (await import('yaml')).default;
+      const text = readFileSync(CONFIG_PATH, 'utf-8');
+      config = YAML.parse(text);
+      results.push({ name: 'Config File', status: 'ok', message: CONFIG_PATH });
+    } catch (err) {
+      results.push({ name: 'Config File', status: 'fail', message: `Invalid YAML: ${err}` });
+    }
+  } else {
+    results.push({ name: 'Config File', status: 'fail', message: 'Not found. Run: jarvis onboard' });
+  }
+
+  // ── Check 4: LLM API Key ─────────────────────────────────────────
+
+  if (config) {
+    const primary = config.llm?.primary ?? 'anthropic';
+    const providerConfig = config.llm?.[primary];
+
+    if (primary === 'ollama') {
+      results.push({ name: 'LLM Provider', status: 'ok', message: `ollama (${providerConfig?.model ?? 'llama3'})` });
+    } else if (providerConfig?.api_key && providerConfig.api_key !== '') {
+      results.push({
+        name: 'LLM Provider',
+        status: 'ok',
+        message: `${primary} (key: ${providerConfig.api_key.slice(0, 10)}...)`,
+      });
+    } else {
+      results.push({ name: 'LLM Provider', status: 'fail', message: `${primary} API key not set` });
+    }
+  } else {
+    results.push({ name: 'LLM Provider', status: 'skip', message: 'No config file' });
+  }
+
+  // ── Check 5: LLM Connectivity ────────────────────────────────────
+
+  if (config) {
+    const spin = startSpinner('Testing LLM connectivity...');
+    try {
+      const { LLMManager, AnthropicProvider, OpenAIProvider, GeminiProvider, OllamaProvider } = await import('../llm/index.ts');
+      const manager = new LLMManager();
+      const primary = config.llm?.primary ?? 'anthropic';
+
+      if (primary === 'anthropic' && config.llm?.anthropic?.api_key) {
+        manager.registerProvider(new AnthropicProvider(config.llm.anthropic.api_key, config.llm.anthropic.model));
+      } else if (primary === 'openai' && config.llm?.openai?.api_key) {
+        manager.registerProvider(new OpenAIProvider(config.llm.openai.api_key, config.llm.openai.model));
+      } else if (primary === 'gemini' && config.llm?.gemini?.api_key) {
+        manager.registerProvider(new GeminiProvider(config.llm.gemini.api_key, config.llm.gemini.model));
+      } else if (primary === 'ollama') {
+        manager.registerProvider(new OllamaProvider(config.llm.ollama?.base_url, config.llm.ollama?.model));
+      }
+
+      manager.setPrimary(primary);
+      const resp = await manager.chat(
+        [{ role: 'user', content: 'Say OK' }],
+        { max_tokens: 10 },
+      );
+      spin.stop();
+      results.push({ name: 'LLM Connectivity', status: 'ok', message: `Model: ${resp.model}` });
+    } catch (err) {
+      spin.stop();
+      results.push({ name: 'LLM Connectivity', status: 'fail', message: String(err).slice(0, 100) });
+    }
+  } else {
+    results.push({ name: 'LLM Connectivity', status: 'skip', message: 'No config file' });
+  }
+
+  // ── Check 6: Browser (Chromium/Chrome) ────────────────────────────
+
+  const browserPaths = process.platform === 'darwin'
+    ? ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/Applications/Chromium.app/Contents/MacOS/Chromium']
+    : ['/usr/bin/chromium-browser', '/usr/bin/chromium', '/usr/bin/google-chrome', '/usr/bin/google-chrome-stable'];
+
+  const foundBrowser = browserPaths.find(p => existsSync(p));
+  if (foundBrowser) {
+    results.push({ name: 'Browser', status: 'ok', message: foundBrowser });
+  } else {
+    // Try which
+    const which = Bun.spawnSync(['which', 'chromium-browser']);
+    if (which.exitCode === 0) {
+      results.push({ name: 'Browser', status: 'ok', message: which.stdout.toString().trim() });
+    } else {
+      results.push({ name: 'Browser', status: 'warn', message: 'Chromium/Chrome not found. Browser tools will be limited.' });
+    }
+  }
+
+  // ── Check 7: Port Availability ────────────────────────────────────
+
+  const port = config?.daemon?.port ?? 3142;
+  try {
+    const server = Bun.serve({ port, fetch: () => new Response('') });
+    server.stop(true);
+    results.push({ name: 'Port', status: 'ok', message: `${port} is available` });
+  } catch {
+    results.push({ name: 'Port', status: 'warn', message: `${port} is in use (daemon may already be running)` });
+  }
+
+  // ── Check 8: SQLite ───────────────────────────────────────────────
+
+  try {
+    const { Database } = await import('bun:sqlite');
+    const db = new Database(':memory:');
+    db.run('CREATE TABLE test (id INTEGER PRIMARY KEY)');
+    db.close();
+    results.push({ name: 'SQLite', status: 'ok', message: 'bun:sqlite working' });
+  } catch (err) {
+    results.push({ name: 'SQLite', status: 'fail', message: String(err) });
+  }
+
+  // ── Check 9: TTS/STT Providers ────────────────────────────────────
+
+  if (config?.tts?.enabled) {
+    results.push({ name: 'TTS', status: 'ok', message: `${config.tts.provider ?? 'edge'} (${config.tts.voice ?? 'default'})` });
+  } else {
+    results.push({ name: 'TTS', status: 'skip', message: 'Disabled' });
+  }
+
+  if (config?.stt?.provider) {
+    const sttProv = config.stt.provider;
+    const hasKey = sttProv === 'ollama' || sttProv === 'local'
+      || (sttProv === 'openai' && config.stt.openai?.api_key)
+      || (sttProv === 'groq' && config.stt.groq?.api_key);
+    results.push({
+      name: 'STT',
+      status: hasKey ? 'ok' : 'warn',
+      message: hasKey ? `${sttProv} configured` : `${sttProv} (API key missing)`,
+    });
+  } else {
+    results.push({ name: 'STT', status: 'skip', message: 'Not configured' });
+  }
+
+  // ── Check 11: Channels ────────────────────────────────────────────
+
+  if (config?.channels?.telegram?.enabled && config.channels.telegram.bot_token) {
+    results.push({ name: 'Telegram', status: 'ok', message: 'Bot token set' });
+  } else {
+    results.push({ name: 'Telegram', status: 'skip', message: 'Not configured' });
+  }
+
+  if (config?.channels?.discord?.enabled && config.channels.discord.bot_token) {
+    results.push({ name: 'Discord', status: 'ok', message: 'Bot token set' });
+  } else {
+    results.push({ name: 'Discord', status: 'skip', message: 'Not configured' });
+  }
+
+  // ── Results ───────────────────────────────────────────────────────
+
+  console.log(c.bold('\nDiagnostics Results:\n'));
+
+  let okCount = 0;
+  let warnCount = 0;
+  let failCount = 0;
+
+  for (const r of results) {
+    const icon = r.status === 'ok' ? c.green('✓')
+      : r.status === 'warn' ? c.yellow('!')
+      : r.status === 'fail' ? c.red('✗')
+      : c.dim('○');
+
+    const nameStr = r.name.padEnd(20);
+    console.log(`  ${icon} ${nameStr} ${c.dim(r.message)}`);
+
+    if (r.status === 'ok') okCount++;
+    else if (r.status === 'warn') warnCount++;
+    else if (r.status === 'fail') failCount++;
+  }
+
+  console.log('');
+  console.log(`  ${c.green(`${okCount} passed`)}  ${c.yellow(`${warnCount} warnings`)}  ${c.red(`${failCount} failed`)}`);
+
+  if (failCount > 0) {
+    console.log(c.red('\nSome checks failed. Run "jarvis onboard" to fix configuration.\n'));
+  } else if (warnCount > 0) {
+    console.log(c.yellow('\nAll critical checks passed, but some optional features need setup.\n'));
+  } else {
+    console.log(c.green('\nAll checks passed! JARVIS is ready.\n'));
+  }
+
+  closeRL();
+}

package/src/cli/helpers.ts

@@ -0,0 +1,401 @@
+/**
+ * CLI Utilities for J.A.R.V.I.S.
+ *
+ * Shared helpers for the interactive CLI: prompts, colors, spinners.
+ * Zero external dependencies — uses built-in readline and ANSI codes.
+ */
+
+import * as readline from 'node:readline';
+import { createReadStream, openSync, closeSync, readFileSync, existsSync } from 'node:fs';
+
+// ── ANSI Colors ──────────────────────────────────────────────────────
+
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+const MAGENTA = '\x1b[35m';
+const BLUE = '\x1b[34m';
+
+export const c = {
+  bold: (s: string) => `${BOLD}${s}${RESET}`,
+  dim: (s: string) => `${DIM}${s}${RESET}`,
+  cyan: (s: string) => `${CYAN}${s}${RESET}`,
+  green: (s: string) => `${GREEN}${s}${RESET}`,
+  yellow: (s: string) => `${YELLOW}${s}${RESET}`,
+  red: (s: string) => `${RED}${s}${RESET}`,
+  magenta: (s: string) => `${MAGENTA}${s}${RESET}`,
+  blue: (s: string) => `${BLUE}${s}${RESET}`,
+};
+
+// ── Readline Interface ───────────────────────────────────────────────
+
+let rl: readline.Interface | null = null;
+let ttyStream: ReturnType<typeof createReadStream> | null = null;
+
+/**
+ * Get a readline interface connected to the terminal.
+ * When stdin is a pipe (e.g. `curl | bash`), falls back to /dev/tty.
+ */
+function getRL(): readline.Interface {
+  if (!rl) {
+    let input: NodeJS.ReadableStream = process.stdin;
+
+    // When stdin is not a TTY (piped), open /dev/tty directly
+    if (!process.stdin.isTTY) {
+      try {
+        // Test that /dev/tty is actually openable (fails in headless/CI)
+        const fd = openSync('/dev/tty', 'r');
+        closeSync(fd);
+        ttyStream = createReadStream('/dev/tty');
+        input = ttyStream;
+      } catch {
+        // No controlling terminal available — fall back to stdin
+      }
+    }
+
+    rl = readline.createInterface({ input, output: process.stdout });
+
+    // If the readline closes unexpectedly (EOF), null it so the next
+    // call to getRL() creates a fresh one from /dev/tty.
+    rl.on('close', () => { rl = null; });
+  }
+  return rl;
+}
+
+export function closeRL(): void {
+  if (rl) {
+    rl.close();
+    rl = null;
+  }
+  if (ttyStream) {
+    ttyStream.close();
+    ttyStream = null;
+  }
+}
+
+// ── Prompt Helpers ───────────────────────────────────────────────────
+
+/**
+ * Ask a free-text question. Returns trimmed answer.
+ */
+export function ask(question: string, defaultValue?: string): Promise<string> {
+  return new Promise((resolve) => {
+    const suffix = defaultValue ? ` ${c.dim(`[${defaultValue}]`)}` : '';
+    getRL().question(`${c.cyan('?')} ${question}${suffix}: `, (answer) => {
+      resolve(answer.trim() || defaultValue || '');
+    });
+  });
+}
+
+/**
+ * Ask for a secret (API key, token). Masks input with asterisks.
+ */
+export function askSecret(question: string): Promise<string> {
+  return new Promise((resolve) => {
+    const r = getRL();
+    process.stdout.write(`${c.cyan('?')} ${question}: `);
+
+    // Temporarily disable echo
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY && stdin.setRawMode) {
+      stdin.setRawMode(true);
+    }
+
+    let input = '';
+
+    const cleanup = () => {
+      stdin.removeListener('data', onData);
+      if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false);
+    };
+
+    const onData = (char: Buffer) => {
+      try {
+        const ch = char.toString();
+        if (ch === '\n' || ch === '\r') {
+          cleanup();
+          process.stdout.write('\n');
+          resolve(input.trim());
+        } else if (ch === '\x7f' || ch === '\b') {
+          if (input.length > 0) {
+            input = input.slice(0, -1);
+            process.stdout.write('\b \b');
+          }
+        } else if (ch === '\x03') {
+          cleanup();
+          process.stdout.write('\n');
+          process.exit(130);
+        } else if (ch.charCodeAt(0) >= 32) {
+          input += ch;
+          process.stdout.write('*');
+        }
+      } catch {
+        cleanup();
+        process.stdout.write('\n');
+        resolve(input.trim());
+      }
+    };
+
+    stdin.on('data', onData);
+  });
+}
+
+/**
+ * Ask a yes/no question. Returns boolean.
+ */
+export function askYesNo(question: string, defaultYes = true): Promise<boolean> {
+  return new Promise((resolve) => {
+    const hint = defaultYes ? 'Y/n' : 'y/N';
+    getRL().question(`${c.cyan('?')} ${question} ${c.dim(`(${hint})`)}: `, (answer) => {
+      const a = answer.trim().toLowerCase();
+      if (a === '') resolve(defaultYes);
+      else resolve(a === 'y' || a === 'yes');
+    });
+  });
+}
+
+/**
+ * Ask user to pick from a list of options.
+ * Supports arrow keys (up/down) and number keys for selection.
+ * Falls back to simple numbered input when raw mode is unavailable.
+ */
+export function askChoice<T extends string>(
+  question: string,
+  options: { label: string; value: T; description?: string }[],
+  defaultValue?: T
+): Promise<T> {
+  let selected = 0;
+  options.forEach((opt, i) => {
+    if (opt.value === defaultValue) selected = i;
+  });
+
+  const stdin = process.stdin;
+
+  // Fall back to simple numbered input if raw mode is unavailable
+  if (!stdin.isTTY || !stdin.setRawMode) {
+    return askChoiceFallback(question, options, selected);
+  }
+
+  return new Promise((resolve) => {
+    // Pause readline so it doesn't compete for stdin
+    if (rl) { rl.pause(); }
+
+    console.log(`\n${c.cyan('?')} ${question} ${c.dim('(↑↓ to move, enter to select)')}`);
+
+    function renderLine(i: number): string {
+      const opt = options[i]!;
+      const marker = i === selected ? c.cyan('❯') : ' ';
+      const label = i === selected ? c.cyan(opt.label) : opt.label;
+      const desc = opt.description ? ` ${c.dim(`- ${opt.description}`)}` : '';
+      return `  ${marker} ${label}${desc}`;
+    }
+
+    function render() {
+      // Move cursor up to overwrite previous render
+      options.forEach(() => process.stdout.write('\x1b[A'));
+      for (let i = 0; i < options.length; i++) {
+        process.stdout.write(`\r\x1b[K${renderLine(i)}\n`);
+      }
+    }
+
+    // Initial draw
+    for (let i = 0; i < options.length; i++) {
+      console.log(renderLine(i));
+    }
+
+    const wasRaw = stdin.isRaw;
+    stdin.setRawMode(true);
+    stdin.resume();
+
+    const cleanup = () => {
+      stdin.removeListener('data', onData);
+      try { stdin.setRawMode(wasRaw ?? false); } catch { /* already restored */ }
+      if (rl) { rl.resume(); }
+    };
+
+    const onData = (data: Buffer) => {
+      try {
+        const key = data.toString();
+
+        if (key === '\x1b[A' || key === 'k') {
+          selected = (selected - 1 + options.length) % options.length;
+          render();
+        } else if (key === '\x1b[B' || key === 'j') {
+          selected = (selected + 1) % options.length;
+          render();
+        } else if (key === '\r' || key === '\n') {
+          cleanup();
+          // Overwrite the list with final selection
+          for (let i = 0; i < options.length; i++) process.stdout.write('\x1b[A');
+          for (let i = 0; i < options.length; i++) {
+            process.stdout.write(`\r\x1b[K`);
+            if (i < options.length - 1) process.stdout.write('\n');
+          }
+          process.stdout.write(`\r\x1b[K  ${c.green('✓')} ${options[selected]!.label}\n`);
+          resolve(options[selected]!.value);
+        } else if (key === '\x03') {
+          cleanup();
+          process.stdout.write('\n');
+          process.exit(130);
+        } else {
+          const num = parseInt(key, 10);
+          if (num >= 1 && num <= options.length) {
+            selected = num - 1;
+            render();
+          }
+        }
+      } catch {
+        cleanup();
+        resolve(options[selected]!.value);
+      }
+    };
+
+    stdin.on('data', onData);
+  });
+}
+
+/** Simple fallback for non-TTY environments. */
+function askChoiceFallback<T extends string>(
+  question: string,
+  options: { label: string; value: T; description?: string }[],
+  defaultIdx: number,
+): Promise<T> {
+  return new Promise((resolve) => {
+    console.log(`\n${c.cyan('?')} ${question}`);
+    options.forEach((opt, i) => {
+      const marker = i === defaultIdx ? c.cyan('>') : ' ';
+      const desc = opt.description ? ` ${c.dim(`- ${opt.description}`)}` : '';
+      console.log(`  ${marker} ${c.bold(`${i + 1}.`)} ${opt.label}${desc}`);
+    });
+
+    getRL().question(`${c.dim(`Enter choice [1-${options.length}]`)}: `, (answer) => {
+      const a = answer.trim();
+      if (a === '') { resolve(options[defaultIdx]!.value); return; }
+      const idx = parseInt(a, 10) - 1;
+      if (idx >= 0 && idx < options.length) {
+        resolve(options[idx]!.value);
+      } else {
+        const match = options.find(o =>
+          o.value.toLowerCase() === a.toLowerCase() ||
+          o.label.toLowerCase() === a.toLowerCase()
+        );
+        resolve(match ? match.value : options[defaultIdx]!.value);
+      }
+    });
+  });
+}
+
+// ── Display Helpers ──────────────────────────────────────────────────
+
+/**
+ * Print a step indicator: [2/9] Title
+ */
+export function printStep(current: number, total: number, title: string): void {
+  console.log(`\n${c.cyan(`[${current}/${total}]`)} ${c.bold(title)}`);
+  console.log(c.dim('─'.repeat(50)));
+}
+
+/**
+ * Print the JARVIS ASCII banner.
+ */
+export function printBanner(): void {
+  console.log(c.cyan(`
+     ██╗ █████╗ ██████╗ ██╗   ██╗██╗███████╗
+     ██║██╔══██╗██╔══██╗██║   ██║██║██╔════╝
+     ██║███████║██████╔╝██║   ██║██║███████╗
+██   ██║██╔══██║██╔══██╗╚██╗ ██╔╝██║╚════██║
+╚█████╔╝██║  ██║██║  ██║ ╚████╔╝ ██║███████║
+ ╚════╝ ╚═╝  ╚═╝╚═╝  ╚═╝  ╚═══╝  ╚═╝╚══════╝`));
+  console.log(c.dim('  Just A Rather Very Intelligent System\n'));
+}
+
+/**
+ * Print a success message with checkmark.
+ */
+export function printOk(message: string): void {
+  console.log(`  ${c.green('✓')} ${message}`);
+}
+
+/**
+ * Print a warning message.
+ */
+export function printWarn(message: string): void {
+  console.log(`  ${c.yellow('!')} ${message}`);
+}
+
+/**
+ * Print an error message.
+ */
+export function printErr(message: string): void {
+  console.log(`  ${c.red('✗')} ${message}`);
+}
+
+/**
+ * Print an info/skip message.
+ */
+export function printInfo(message: string): void {
+  console.log(`  ${c.dim('○')} ${message}`);
+}
+
+// ── Spinner ──────────────────────────────────────────────────────────
+
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+export interface Spinner {
+  stop: (message?: string) => void;
+  update: (text: string) => void;
+}
+
+/**
+ * Start a CLI spinner. Returns { stop(msg?), update(text) }.
+ */
+export function startSpinner(text: string): Spinner {
+  let frame = 0;
+  let currentText = text;
+  let stopped = false;
+
+  const interval = setInterval(() => {
+    if (stopped) return;
+    process.stdout.write(`\r  ${c.cyan(SPINNER_FRAMES[frame % SPINNER_FRAMES.length]!)} ${currentText}`);
+    frame++;
+  }, 80);
+
+  return {
+    stop(message?: string) {
+      if (stopped) return;
+      stopped = true;
+      clearInterval(interval);
+      process.stdout.write('\r' + ' '.repeat(currentText.length + 10) + '\r');
+      if (message) printOk(message);
+    },
+    update(newText: string) {
+      currentText = newText;
+    },
+  };
+}
+
+// ── Utility ──────────────────────────────────────────────────────────
+
+/**
+ * Detect platform context.
+ */
+export function detectPlatform(): 'macos' | 'linux' | 'wsl' {
+  if (process.platform === 'darwin') return 'macos';
+
+  try {
+    if (existsSync('/proc/version')) {
+      const text = readFileSync('/proc/version', 'utf-8').toLowerCase();
+      if (text.includes('microsoft') || text.includes('wsl')) {
+        return 'wsl';
+      }
+    }
+  } catch {
+    // Not Linux or can't read /proc
+  }
+
+  return 'linux';
+}