brains-cli 0.1.0 → 1.0.2

package/src/config.js

@@ -0,0 +1,237 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { getProviderDef } = require('./providers/registry');
+
+const BRAINS_DIR = path.join(os.homedir(), '.brains');
+const CONFIG_FILE = path.join(BRAINS_DIR, 'config.json');
+const SESSIONS_DIR = path.join(BRAINS_DIR, 'sessions');
+
+const DEFAULTS = {
+  provider: 'groq',
+  max_tokens: 8096,
+  theme: 'dark',
+  telemetry: false,
+};
+
+function ensureDirs() {
+  if (!fs.existsSync(BRAINS_DIR)) {
+    fs.mkdirSync(BRAINS_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(SESSIONS_DIR)) {
+    fs.mkdirSync(SESSIONS_DIR, { recursive: true });
+  }
+}
+
+function loadConfig() {
+  ensureDirs();
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const raw = JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+      return migrateConfig(raw);
+    }
+  } catch (e) {
+    // corrupted config, reset
+  }
+  return { ...DEFAULTS, providers: {} };
+}
+
+/**
+ * Migrate old config format (flat api_key/model) to new provider-based format.
+ */
+function migrateConfig(raw) {
+  const config = { ...DEFAULTS, ...raw };
+
+  // Ensure providers object exists
+  if (!config.providers) {
+    config.providers = {};
+  }
+
+  // Migrate old flat api_key → providers.anthropic.api_key
+  if (config.api_key && !config.providers.anthropic) {
+    config.providers.anthropic = {
+      api_key: config.api_key,
+      model: config.model || 'claude-sonnet-4-20250514',
+    };
+    delete config.api_key;
+  }
+
+  // Migrate old flat model if it was an anthropic model
+  if (config.model && config.model.startsWith('claude-')) {
+    if (!config.providers.anthropic) config.providers.anthropic = {};
+    config.providers.anthropic.model = config.model;
+    delete config.model;
+  } else if (config.model) {
+    delete config.model;
+  }
+
+  // If no provider is set, default to groq
+  if (!config.provider) {
+    config.provider = DEFAULTS.provider;
+  }
+
+  return config;
+}
+
+function saveConfig(config) {
+  ensureDirs();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+function getConfigValue(key) {
+  const config = loadConfig();
+  return config[key];
+}
+
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  config[key] = value;
+  saveConfig(config);
+}
+
+// ═══════════════════════════════════════════
+//  PROVIDER-AWARE GETTERS
+// ═══════════════════════════════════════════
+
+/**
+ * Get the currently active provider name.
+ */
+function getActiveProvider() {
+  const config = loadConfig();
+  return config.provider || DEFAULTS.provider;
+}
+
+/**
+ * Resolve API key for a provider: env var > config > null
+ */
+function getProviderApiKey(providerName) {
+  const providerDef = getProviderDef(providerName);
+
+  // 1. Check environment variable
+  if (providerDef && providerDef.key_env && process.env[providerDef.key_env]) {
+    return process.env[providerDef.key_env];
+  }
+
+  // 2. Check config file
+  const config = loadConfig();
+  const providerConfig = config.providers && config.providers[providerName];
+  if (providerConfig && providerConfig.api_key) {
+    return providerConfig.api_key;
+  }
+
+  return null;
+}
+
+/**
+ * Get the model for a provider: config > default
+ */
+function getProviderModel(providerName) {
+  const config = loadConfig();
+  const providerConfig = config.providers && config.providers[providerName];
+  if (providerConfig && providerConfig.model) {
+    return providerConfig.model;
+  }
+
+  // Fallback to provider's default model
+  const providerDef = getProviderDef(providerName);
+  return providerDef ? providerDef.default_model : 'unknown';
+}
+
+/**
+ * Get the base URL for a provider: config override > provider default
+ */
+function getProviderBaseUrl(providerName) {
+  const config = loadConfig();
+  const providerConfig = config.providers && config.providers[providerName];
+  if (providerConfig && providerConfig.base_url) {
+    return providerConfig.base_url;
+  }
+
+  const providerDef = getProviderDef(providerName);
+  return providerDef ? providerDef.base_url : null;
+}
+
+/**
+ * Save API key for a specific provider.
+ */
+function setProviderApiKey(providerName, apiKey) {
+  const config = loadConfig();
+  if (!config.providers) config.providers = {};
+  if (!config.providers[providerName]) config.providers[providerName] = {};
+  config.providers[providerName].api_key = apiKey;
+  saveConfig(config);
+}
+
+/**
+ * Save model for a specific provider.
+ */
+function setProviderModel(providerName, model) {
+  const config = loadConfig();
+  if (!config.providers) config.providers = {};
+  if (!config.providers[providerName]) config.providers[providerName] = {};
+  config.providers[providerName].model = model;
+  saveConfig(config);
+}
+
+/**
+ * Switch the active provider.
+ */
+function setActiveProvider(providerName) {
+  const config = loadConfig();
+  config.provider = providerName;
+  saveConfig(config);
+}
+
+// ═══════════════════════════════════════════
+//  BACKWARD-COMPAT GETTERS (used by run.js session header)
+// ═══════════════════════════════════════════
+
+function getModel() {
+  return getProviderModel(getActiveProvider());
+}
+
+function getApiKey() {
+  return getProviderApiKey(getActiveProvider());
+}
+
+function maskApiKey(key) {
+  if (!key || key.length < 12) return '(not set)';
+  return key.slice(0, 7) + '...' + key.slice(-4);
+}
+
+function saveSession(brainId, messages) {
+  ensureDirs();
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  const sessionFile = path.join(SESSIONS_DIR, `${brainId}-${timestamp}.json`);
+  fs.writeFileSync(sessionFile, JSON.stringify({
+    brainId,
+    timestamp: new Date().toISOString(),
+    messages,
+  }, null, 2));
+  return sessionFile;
+}
+
+module.exports = {
+  BRAINS_DIR,
+  CONFIG_FILE,
+  SESSIONS_DIR,
+  DEFAULTS,
+  loadConfig,
+  saveConfig,
+  getConfigValue,
+  setConfigValue,
+  getActiveProvider,
+  getProviderApiKey,
+  getProviderModel,
+  getProviderBaseUrl,
+  setProviderApiKey,
+  setProviderModel,
+  setActiveProvider,
+  getApiKey,
+  getModel,
+  maskApiKey,
+  saveSession,
+  ensureDirs,
+};

package/src/providers/anthropic.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const Anthropic = require('@anthropic-ai/sdk');
+
+let client = null;
+let cachedKey = null;
+
+function getClient(apiKey) {
+  // Re-create if key changed
+  if (client && cachedKey === apiKey) return client;
+  client = new Anthropic({ apiKey });
+  cachedKey = apiKey;
+  return client;
+}
+
+/**
+ * Stream a message using Anthropic's native API.
+ * System prompt is a separate parameter (not a message).
+ */
+async function streamMessage(opts) {
+  const {
+    apiKey,
+    systemPrompt,
+    messages,
+    maxTokens,
+    model,
+    onText,
+    onStart,
+    onEnd,
+  } = opts;
+
+  const anthropic = getClient(apiKey);
+  let fullText = '';
+
+  const stream = await anthropic.messages.stream({
+    model,
+    max_tokens: maxTokens,
+    system: systemPrompt,
+    messages,
+  });
+
+  onStart();
+
+  for await (const event of stream) {
+    if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
+      const text = event.delta.text;
+      fullText += text;
+      onText(text);
+    }
+  }
+
+  onEnd();
+  return fullText;
+}
+
+/**
+ * Send a single message (non-streaming).
+ */
+async function sendMessage(opts) {
+  const {
+    apiKey,
+    systemPrompt,
+    messages,
+    maxTokens,
+    model,
+  } = opts;
+
+  const anthropic = getClient(apiKey);
+
+  const response = await anthropic.messages.create({
+    model,
+    max_tokens: maxTokens,
+    system: systemPrompt,
+    messages,
+  });
+
+  return response.content
+    .filter((block) => block.type === 'text')
+    .map((block) => block.text)
+    .join('');
+}
+
+module.exports = { streamMessage, sendMessage };

package/src/providers/openai-compat.js

@@ -0,0 +1,96 @@
+'use strict';
+
+const OpenAI = require('openai');
+
+const clients = {};
+
+function getClient(baseURL, apiKey) {
+  const cacheKey = baseURL + '::' + (apiKey || 'nokey');
+  if (clients[cacheKey]) return clients[cacheKey];
+
+  clients[cacheKey] = new OpenAI({
+    apiKey: apiKey || 'ollama',  // Ollama doesn't need a key but SDK requires one
+    baseURL,
+  });
+
+  return clients[cacheKey];
+}
+
+/**
+ * Stream a message using OpenAI-compatible API (Groq, Gemini, OpenRouter, Ollama).
+ * System prompt becomes a system message.
+ */
+async function streamMessage(opts) {
+  const {
+    apiKey,
+    baseURL,
+    systemPrompt,
+    messages,
+    maxTokens,
+    model,
+    onText,
+    onStart,
+    onEnd,
+  } = opts;
+
+  const openai = getClient(baseURL, apiKey);
+
+  // Convert Anthropic-style (separate system) to OpenAI-style (system message)
+  const fullMessages = [
+    { role: 'system', content: systemPrompt },
+    ...messages,
+  ];
+
+  let fullText = '';
+
+  const stream = await openai.chat.completions.create({
+    model,
+    max_tokens: maxTokens,
+    messages: fullMessages,
+    stream: true,
+  });
+
+  onStart();
+
+  for await (const chunk of stream) {
+    const text = chunk.choices[0]?.delta?.content;
+    if (text) {
+      fullText += text;
+      onText(text);
+    }
+  }
+
+  onEnd();
+  return fullText;
+}
+
+/**
+ * Send a single message (non-streaming).
+ */
+async function sendMessage(opts) {
+  const {
+    apiKey,
+    baseURL,
+    systemPrompt,
+    messages,
+    maxTokens,
+    model,
+  } = opts;
+
+  const openai = getClient(baseURL, apiKey);
+
+  const fullMessages = [
+    { role: 'system', content: systemPrompt },
+    ...messages,
+  ];
+
+  const response = await openai.chat.completions.create({
+    model,
+    max_tokens: maxTokens,
+    messages: fullMessages,
+  });
+
+  return response.choices[0]?.message?.content || '';
+}
+
+module.exports = { streamMessage, sendMessage };

package/src/providers/registry.js

@@ -0,0 +1,125 @@
+'use strict';
+
+/**
+ * Provider Registry — defines all supported AI providers.
+ *
+ * Each provider has:
+ *   type        — 'anthropic' or 'openai' (OpenAI-compatible API)
+ *   name        — Display name
+ *   base_url    — API endpoint (for openai-type providers)
+ *   default_model — Fallback model
+ *   models      — Available models
+ *   key_prefix  — Expected API key prefix (for validation hint)
+ *   key_env     — Environment variable to check for API key
+ *   key_url     — Where to get an API key
+ *   requires_key — false for providers that don't need a key (Ollama)
+ *   free        — true if provider has a free tier
+ */
+const PROVIDERS = {
+  groq: {
+    name: 'Groq',
+    type: 'openai',
+    base_url: 'https://api.groq.com/openai/v1',
+    default_model: 'llama-3.3-70b-versatile',
+    models: [
+      'llama-3.3-70b-versatile',
+      'llama-3.1-8b-instant',
+      'mixtral-8x7b-32768',
+      'gemma2-9b-it',
+    ],
+    key_prefix: 'gsk_',
+    key_env: 'GROQ_API_KEY',
+    key_url: 'https://console.groq.com/',
+    requires_key: true,
+    free: true,
+  },
+
+  anthropic: {
+    name: 'Anthropic (Claude)',
+    type: 'anthropic',
+    base_url: null,
+    default_model: 'claude-sonnet-4-20250514',
+    models: [
+      'claude-sonnet-4-20250514',
+      'claude-haiku-4-20250514',
+    ],
+    key_prefix: 'sk-ant-',
+    key_env: 'ANTHROPIC_API_KEY',
+    key_url: 'https://console.anthropic.com/',
+    requires_key: true,
+    free: false,
+  },
+
+  gemini: {
+    name: 'Google Gemini',
+    type: 'openai',
+    base_url: 'https://generativelanguage.googleapis.com/v1beta/openai/',
+    default_model: 'gemini-2.0-flash',
+    models: [
+      'gemini-2.0-flash',
+      'gemini-1.5-flash',
+      'gemini-1.5-pro',
+    ],
+    key_prefix: '',
+    key_env: 'GEMINI_API_KEY',
+    key_url: 'https://aistudio.google.com/',
+    requires_key: true,
+    free: true,
+  },
+
+  openrouter: {
+    name: 'OpenRouter',
+    type: 'openai',
+    base_url: 'https://openrouter.ai/api/v1',
+    default_model: 'meta-llama/llama-3.3-70b-instruct:free',
+    models: [
+      'meta-llama/llama-3.3-70b-instruct:free',
+      'mistralai/mistral-7b-instruct:free',
+      'google/gemma-2-9b-it:free',
+    ],
+    key_prefix: 'sk-or-',
+    key_env: 'OPENROUTER_API_KEY',
+    key_url: 'https://openrouter.ai/',
+    requires_key: true,
+    free: true,
+  },
+
+  ollama: {
+    name: 'Ollama (Local)',
+    type: 'openai',
+    base_url: 'http://localhost:11434/v1',
+    default_model: 'llama3',
+    models: [
+      'llama3',
+      'llama3.1',
+      'codellama',
+      'mistral',
+      'mixtral',
+      'phi3',
+    ],
+    key_prefix: '',
+    key_env: '',
+    key_url: 'https://ollama.com/',
+    requires_key: false,
+    free: true,
+  },
+};
+
+function getProviderDef(name) {
+  return PROVIDERS[name] || null;
+}
+
+function getAllProviderNames() {
+  return Object.keys(PROVIDERS);
+}
+
+function getAllProviders() {
+  return PROVIDERS;
+}
+
+module.exports = {
+  PROVIDERS,
+  getProviderDef,
+  getAllProviderNames,
+  getAllProviders,
+};