@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-2RRBMNBQ.js

@@ -0,0 +1,322 @@
+import {
+  bbDataDir
+} from "./chunk-2BSKD7O3.js";
+
+// src/setup/setup-wizard.ts
+import { existsSync, readFileSync, writeFileSync, statSync, mkdirSync, renameSync, chmodSync } from "fs";
+import path from "path";
+import * as readline from "readline";
+var PROVIDERS = [
+  {
+    id: "openrouter-free",
+    label: "OpenRouter (free tier)",
+    baseURL: "https://openrouter.ai/api/v1",
+    model: "liquid/lfm-2.5-embedding-350m:free",
+    keyHint: "openrouter.ai/keys \u2014 free key, rate-limited"
+  },
+  {
+    id: "nvidia-nim",
+    label: "NVIDIA NIM (free tier)",
+    baseURL: "https://integrate.api.nvidia.com/v1",
+    model: "nvidia/nemotron-3-embed-1b",
+    keyHint: "build.nvidia.com \u2014 free key, rate-limited"
+  },
+  {
+    id: "custom",
+    label: "Custom / paid provider",
+    baseURL: null,
+    model: null,
+    keyHint: "OpenAI-compatible /embeddings endpoint"
+  }
+];
+function readJson(p) {
+  try {
+    if (existsSync(p)) return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+  }
+  return null;
+}
+function hasEmbeddingConfig(cwd = process.cwd(), env = process.env) {
+  if (env.BB_EMBEDDING_BASE_URL && env.BB_EMBEDDING_MODEL) return { configured: true, source: "env" };
+  const home = readJson(path.join(bbDataDir(), "config.json"));
+  if (home && home.embedding_base_url && home.embedding_model) return { configured: true, source: "global" };
+  const local = readJson(path.join(cwd, "bb.json"));
+  if (local && local.embedding_base_url && local.embedding_model) return { configured: true, source: "project" };
+  if (home && home.setup_skipped === true) return { configured: false, source: "none", skipped: true };
+  return { configured: false, source: "none" };
+}
+function mapValidationError(status, bodyText) {
+  if (status === 401 || status === 403) {
+    return "Key rejected (401). Check the key and provider \u2014 copy-paste may have dropped or added characters.";
+  }
+  if (status === 429) {
+    return "Rate limit (429). The key looks valid; free-tier limit. It can be saved \u2014 indexing backs off and retries.";
+  }
+  if (status >= 500) {
+    return `Provider error (${status}). The key may be valid; the provider is temporarily failing. It can be saved \u2014 indexing retries automatically.`;
+  }
+  if (status === 404) {
+    return `Model not found (404). Check the model name: the provider's /embeddings endpoint does not recognize it.`;
+  }
+  return `Unexpected response (${status}): ${(bodyText || "").slice(0, 120)}`;
+}
+function firstEmbedding(response) {
+  if (typeof response !== "object" || response === null) return void 0;
+  if (!("data" in response)) return void 0;
+  const list = response.data;
+  if (!Array.isArray(list) || list.length === 0) return void 0;
+  const first = list[0];
+  if (typeof first !== "object" || first === null) return void 0;
+  if (!("embedding" in first)) return void 0;
+  return first.embedding;
+}
+async function validateKey(baseURL, apiKey, model, fetchImpl = fetch) {
+  const url = `${baseURL.replace(/\/+$/, "")}/embeddings`;
+  try {
+    const parsed = new URL(url);
+    if (parsed.hostname === "localhost" || parsed.hostname === "127.0.0.1" || parsed.hostname === "[::1]" || parsed.hostname === "::1") {
+      const loopbackHosts = ["127.0.0.1", "localhost", "::1"];
+      for (const key of ["NO_PROXY", "no_proxy"]) {
+        const existing = process.env[key] ?? "";
+        const values = new Set(existing.split(",").map((v) => v.trim()).filter(Boolean));
+        for (const host of loopbackHosts) values.add(host);
+        process.env[key] = [...values].join(",");
+      }
+    }
+  } catch {
+  }
+  let res;
+  try {
+    res = await fetchImpl(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+        // [pin]
+      },
+      body: JSON.stringify({ model, input: "test", encoding_format: "float" }),
+      signal: AbortSignal.timeout(15e3)
+      // [pin]
+    });
+  } catch (caught) {
+    const e = caught instanceof Error ? caught : caught;
+    if (e && (e.name === "TimeoutError" || e.name === "AbortError")) {
+      throw new Error("Provider did not respond (timeout). Check your internet connection and the base URL.");
+    }
+    throw new Error(`Could not reach the provider: ${e?.message || e}. Check the base URL.`);
+  }
+  if (res.status === 429 || res.status >= 500) {
+    return { softPass: true, status: res.status, model, fingerprint: fingerprintKey(apiKey) };
+  }
+  if (res.status < 200 || res.status >= 300) {
+    throw new Error(mapValidationError(res.status, await res.text().catch(() => "")));
+  }
+  let data;
+  try {
+    data = await res.json();
+  } catch {
+    throw new Error("Provider returned invalid JSON. The base URL must be a /v1 endpoint.");
+  }
+  const vec = firstEmbedding(data);
+  if (!Array.isArray(vec) || vec.length === 0) {
+    throw new Error("Provider returned no embedding. Check the base URL and model name.");
+  }
+  return { softPass: false, status: res.status, model, dimension: vec.length, fingerprint: fingerprintKey(apiKey) };
+}
+function fingerprintKey(key) {
+  return key && key.length >= 4 ? key.slice(-4) : "****";
+}
+function saveEmbeddingConfig(partial, dataDir = bbDataDir()) {
+  const dir = dataDir;
+  mkdirSync(dir, { recursive: true });
+  const cfgPath = path.join(dir, "config.json");
+  const existing = readJson(cfgPath) || {};
+  const merged = { ...existing, ...partial };
+  const tmp = cfgPath + ".tmp";
+  writeFileSync(tmp, JSON.stringify(merged, null, 2) + "\n", { mode: 384 });
+  renameSync(tmp, cfgPath);
+  fixConfigMode(cfgPath);
+  return cfgPath;
+}
+function fixConfigMode(cfgPath) {
+  try {
+    const mode = statSync(cfgPath).mode & 511;
+    if (mode !== 384) {
+      chmodSync(cfgPath, 384);
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
+function question(rl, prompt) {
+  return new Promise((resolve) => rl.question(prompt, resolve));
+}
+function hiddenQuestion(input, prompt) {
+  return new Promise((resolve) => {
+    const stdin = input;
+    const wasRaw = stdin.isRaw === true;
+    if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(true);
+    process.stdout.write(prompt);
+    let value = "";
+    const onKeypress = (ch, key) => {
+      if (key && key.name === "enter") {
+        cleanup();
+        process.stdout.write("\n");
+        resolve(value);
+        return;
+      }
+      if (key && key.name === "backspace") {
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+        return;
+      }
+      if (key && key.ctrl && key.name === "c") {
+        cleanup();
+        process.stdout.write("\n");
+        resolve(null);
+        process.exit(130);
+      }
+      if (ch && !key?.ctrl && !key?.meta) {
+        value += ch;
+        process.stdout.write("*");
+      }
+    };
+    const { emitKeypressEvents } = readline;
+    emitKeypressEvents(stdin);
+    stdin.on("keypress", onKeypress);
+    function cleanup() {
+      stdin.removeListener("keypress", onKeypress);
+      if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw);
+    }
+  });
+}
+async function runSetupWizard(io = { input: process.stdin, output: process.stdout }, deps = {}) {
+  const out = io.output;
+  const rl = readline.createInterface({ input: io.input, output: io.output });
+  const fetchImpl = deps.fetchImpl || fetch;
+  const dataDir = deps.dataDir || bbDataDir();
+  const save = deps.saveImpl || saveEmbeddingConfig;
+  const validate = deps.validateImpl || validateKey;
+  out.write("\nbb \u2014 embedding setup\n");
+  out.write("Semantic search (bb_search, bb_ask) works with embedding vectors.\n");
+  out.write("Without a key: local word vectors are used \u2014 weaker results.\n");
+  out.write("After adding a model, `bb index --force` is required to refresh the old index.\n\n");
+  const providers = PROVIDERS;
+  out.write("Choose an embedding provider:\n");
+  providers.forEach((p, i) => {
+    out.write(`  ${i + 1}. ${p.label}
+`);
+    if (p.baseURL) out.write(`     ${p.model} \u2014 ${p.keyHint}
+`);
+    else out.write(`     ${p.keyHint}
+`);
+  });
+  out.write(`  ${providers.length + 1}. Skip \u2014 continue with local vectors
+
+`);
+  const answer = (await question(rl, `Choice [1-${providers.length + 1}]: `)).trim();
+  const choice = parseInt(answer, 10);
+  if (!choice || choice < 1 || choice > providers.length + 1) {
+    out.write("Invalid choice \u2014 setup skipped.\n");
+    rl.close();
+    return { saved: false, skipped: true, reason: "invalid-choice" };
+  }
+  if (choice === providers.length + 1) {
+    out.write("Continuing with local word vectors. They give weaker results;\n");
+    out.write("when you add a real model, refresh the index with `bb index --force`.\n");
+    save({ setup_skipped: true }, dataDir);
+    rl.close();
+    return { saved: false, skipped: true, reason: "user-skipped" };
+  }
+  const provider = providers[choice - 1];
+  let baseURL = provider.baseURL;
+  let model = provider.model;
+  if (provider.id === "custom") {
+    const b = (await question(rl, "Base URL (e.g. https://api.openai.com/v1): ")).trim();
+    if (!b) {
+      out.write("Base URL is empty \u2014 setup skipped.\n");
+      rl.close();
+      return { saved: false, skipped: true, reason: "empty-base-url" };
+    }
+    baseURL = b;
+    const m = (await question(rl, "Model name (e.g. text-embedding-3-small): ")).trim();
+    if (!m) {
+      out.write("Model name is empty \u2014 setup skipped.\n");
+      rl.close();
+      return { saved: false, skipped: true, reason: "empty-model" };
+    }
+    model = m;
+  }
+  if (typeof baseURL !== "string" || typeof model !== "string") {
+    out.write("Provider entry has no base URL or model \u2014 setup skipped.\n");
+    rl.close();
+    return { saved: false, skipped: true, reason: "provider-incomplete" };
+  }
+  const key = await hiddenQuestion(io.input, "API key (input hidden): ");
+  rl.close();
+  if (!key || !key.trim()) {
+    out.write("Key is empty \u2014 setup skipped.\n");
+    return { saved: false, skipped: true, reason: "empty-key" };
+  }
+  out.write("Validating key\u2026\n");
+  let validation;
+  try {
+    validation = await validate(baseURL, key.trim(), model);
+  } catch (caught) {
+    const e = caught instanceof Error ? caught : typeof caught === "object" && caught !== null ? caught : {};
+    out.write(`\u2717 ${e.message}
+`);
+    out.write("Key NOT saved. Fix the settings and try again with `bb setup`.\n");
+    return { saved: false, skipped: true, reason: "validation-failed", error: String(e.message) };
+  }
+  save({
+    embedding_base_url: baseURL,
+    embedding_api_key: key.trim(),
+    embedding_model: model
+  }, dataDir);
+  if (validation.softPass) {
+    out.write(`\u2713 Key saved (provider returned a rate limit \u2014 indexing retries automatically).
+`);
+  } else {
+    out.write(`\u2713 Key saved and validated (${model}, ${validation.dimension} dimensions).
+`);
+  }
+  out.write(`Saved to: ${path.join(dataDir, "config.json")} (only your account can read it)
+`);
+  return {
+    saved: true,
+    provider: provider.id,
+    model,
+    fingerprint: validation.fingerprint,
+    softPass: validation.softPass === true
+  };
+}
+async function maybeRunFirstRunSetup(opts = {}) {
+  if (opts.noSetup) return { prompted: false, reason: "flag" };
+  const state = hasEmbeddingConfig(process.cwd(), process.env);
+  if (state.configured) return { prompted: false, reason: "configured" };
+  if (state.skipped) return { prompted: false, reason: "skipped" };
+  if (!process.stdin.isTTY) {
+    if (!opts.quiet) {
+      console.log("note: no embedding key \u2014 semantic search will use local vectors (weaker). Setup: bb setup");
+    }
+    return { prompted: false, reason: "non-tty" };
+  }
+  const result = await runSetupWizard();
+  return { prompted: true, ...result };
+}
+
+export {
+  PROVIDERS,
+  hasEmbeddingConfig,
+  mapValidationError,
+  validateKey,
+  fingerprintKey,
+  saveEmbeddingConfig,
+  fixConfigMode,
+  runSetupWizard,
+  maybeRunFirstRunSetup
+};