@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-J4PMBXQQ.js

@@ -0,0 +1,336 @@
+import {
+  fingerprintKey
+} from "./chunk-2RRBMNBQ.js";
+import {
+  SemanticEngine,
+  assessEndpoint,
+  classifyStatus,
+  describeEmbeddingSetup,
+  isEmbeddingDisabled,
+  observedEmbeddingFailures,
+  parseEndpoint,
+  probeEmbeddingEndpoint,
+  readRuntimeOptions
+} from "./chunk-5SD45FLC.js";
+import {
+  LOCAL_VECTOR_DIMENSION
+} from "./chunk-7AN7U5IZ.js";
+import {
+  bbDataDir
+} from "./chunk-2BSKD7O3.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/setup/setup-show.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import path from "path";
+
+// src/brain/semantic/embedding-diagnosis.ts
+var embedding_diagnosis_exports = {};
+__export(embedding_diagnosis_exports, {
+  LOCAL_DIMENSION: () => LOCAL_DIMENSION,
+  buildEmbeddingChain: () => buildEmbeddingChain,
+  buildEmbeddingDiagnosis: () => buildEmbeddingDiagnosis,
+  embeddingChainVerdict: () => embeddingChainVerdict,
+  probeEmbeddingDiagnosis: () => probeEmbeddingDiagnosis,
+  renderChainSummary: () => renderChainSummary,
+  severityOf: () => severityOf
+});
+var LOCAL_LABEL_HINT = SemanticEngine.LOCAL_MODEL_LABEL;
+function sourceLabel(tier, field) {
+  return tier === "env" ? `env:BB_EMBEDDING_${field}` : `file:${tier}`;
+}
+function buildEmbeddingChain(state, env = process.env) {
+  const options = readRuntimeOptions(env);
+  const layers = [];
+  const winner = state.tiers.find((t) => t.tier === state.winner && t.complete);
+  if (isEmbeddingDisabled(env)) {
+    layers.push({
+      order: 0,
+      role: "disabled",
+      label: "embeddings disabled",
+      endpoint: "none",
+      model: "none",
+      keyState: "not-required",
+      source: "env:BB_EMBEDDING_DISABLED",
+      active: true,
+      problems: []
+    });
+  }
+  if (state.configured && winner) {
+    const hasKey = typeof winner.keyFingerprint === "string" && winner.keyFingerprint.length > 0;
+    const readiness = assessEndpoint(
+      winner.baseURL ?? "",
+      hasKey ? sourceLabel(winner.tier, "API_KEY") : "none",
+      hasKey ? sourceLabel(winner.tier, "API_KEY") : "none"
+    );
+    layers.push({
+      order: layers.length,
+      role: "primary",
+      label: `primary provider (${winner.tier})`,
+      endpoint: winner.baseURL ?? "",
+      model: winner.model ?? "",
+      keyState: readiness.hasKey ? "present" : readiness.loopback ? "not-required" : "absent",
+      source: `url ${sourceLabel(winner.tier, "BASE_URL")} \xB7 model ${sourceLabel(winner.tier, "MODEL")} \xB7 key ${hasKey ? sourceLabel(winner.tier, "API_KEY") : "none"}`,
+      active: !options.disabled,
+      problems: readiness.problems
+    });
+  }
+  if (options.fallback) {
+    const fbKeySource = options.fallback.apiKey ? "env:BB_EMBEDDING_API_KEY" : "none";
+    const readiness = assessEndpoint(options.fallback.baseURL, fbKeySource, "env:BB_EMBEDDING_FALLBACK_API_KEY");
+    layers.push({
+      order: layers.length,
+      role: "fallback",
+      label: "fallback provider",
+      endpoint: options.fallback.baseURL,
+      model: options.fallback.model,
+      keyState: readiness.hasKey ? "present" : readiness.loopback ? "not-required" : "absent",
+      source: `url env:BB_EMBEDDING_FALLBACK_BASE_URL \xB7 model env:BB_EMBEDDING_FALLBACK_MODEL \xB7 key ${options.fallback.apiKey ? "env:BB_EMBEDDING_FALLBACK_API_KEY" : "none"}`,
+      active: !options.disabled && state.configured,
+      problems: readiness.problems
+    });
+  }
+  layers.push({
+    order: layers.length,
+    role: "local",
+    label: "local word vectors",
+    endpoint: "offline",
+    model: LOCAL_LABEL_HINT,
+    keyState: "not-required",
+    source: "built in",
+    active: true,
+    problems: []
+  });
+  return layers;
+}
+function detectTierOrderDisagreement(state, env) {
+  if (state.winner !== "global") return null;
+  const project = state.tiers.find((t) => t.tier === "project");
+  if (!project?.complete) return null;
+  const explicit = (env.BB_CONFIG_FILE ?? "").trim();
+  return {
+    reported: state.winner,
+    actual: explicit ? "BB_CONFIG_FILE" : "project",
+    detail: `bb setup show and bb doctor report the global tier as the winner, but the runtime merges the file tiers project-last (bb.json overrides ~/.bb/config.json), so indexing actually uses ${explicit ? "BB_CONFIG_FILE" : "the project's bb.json"}` + (project.model ? ` (model ${project.model})` : "") + `.`
+  };
+}
+function reconstructSources(state) {
+  const firstWith = (field, pick, fallback) => {
+    for (const tier of state.tiers) {
+      const value = pick(tier);
+      if (typeof value === "string" && value.length > 0) return sourceLabel(tier.tier, field);
+    }
+    return fallback;
+  };
+  return {
+    baseURL: firstWith("BASE_URL", (t) => t.baseURL, "default"),
+    model: firstWith("MODEL", (t) => t.model, "default"),
+    apiKey: firstWith("API_KEY", (t) => t.keyFingerprint, "none")
+  };
+}
+function buildEmbeddingDiagnosis(opts) {
+  const env = opts.env ?? process.env;
+  const state = opts.state;
+  const chain = buildEmbeddingChain(state, env);
+  const winner = state.tiers.find((t) => t.tier === state.winner && t.complete);
+  const sources = reconstructSources(state);
+  const setup = describeEmbeddingSetup(
+    { baseURL: winner?.baseURL ?? "", model: winner?.model ?? "", configured: state.configured, sources },
+    env
+  );
+  const observed = opts.observedFailures ?? observedEmbeddingFailures().map((f) => ({ ...f, latched: true }));
+  return {
+    disabled: isEmbeddingDisabled(env),
+    configured: state.configured,
+    remoteReady: setup.remoteReady && !isEmbeddingDisabled(env),
+    fallbackConfigured: chain.some((l) => l.role === "fallback"),
+    primaryLayer: chain.find((l) => l.role === "primary") ?? null,
+    chain,
+    problems: setup.problems,
+    observedFailures: observed,
+    probe: null,
+    tierOrderDisagreement: detectTierOrderDisagreement(state, env)
+  };
+}
+async function probeEmbeddingDiagnosis(diagnosis, env = process.env) {
+  const layer = diagnosis.primaryLayer;
+  if (!layer || diagnosis.disabled) return { ...diagnosis, probe: null };
+  const endpoint = parseEndpoint(layer.endpoint);
+  const key = readApiKeyForProbe(layer, env);
+  const result = await probeEmbeddingEndpoint(
+    { baseURL: layer.endpoint, apiKey: key, model: layer.model },
+    { timeoutMs: Math.min(readRuntimeOptions(env).timeoutMs, 15e3) }
+  );
+  return {
+    ...diagnosis,
+    probe: {
+      ok: result.ok,
+      elapsedMs: result.elapsedMs,
+      endpoint: layer.endpoint,
+      model: layer.model,
+      dimension: result.dimension,
+      status: result.status,
+      kind: result.kind ?? (result.ok ? void 0 : classifyStatus(result.status ?? 0)),
+      advice: result.advice,
+      message: result.message
+    }
+  };
+}
+function readApiKeyForProbe(layer, env) {
+  if (layer.keyState === "absent") return "";
+  if (layer.source.startsWith("env:")) return env.BB_EMBEDDING_API_KEY ?? "";
+  return "";
+}
+function severityOf(problem) {
+  return problem.severity;
+}
+function renderChainSummary(diagnosis) {
+  return diagnosis.chain.map((l) => {
+    const mark = l.active ? "\u2192" : " ";
+    const target = l.role === "local" ? `${l.endpoint} \xB7 ${LOCAL_VECTOR_DIMENSION}-dim` : `${l.endpoint} \xB7 ${l.model}`;
+    const key = l.role === "local" || l.role === "disabled" ? "" : ` \xB7 key ${l.keyState}`;
+    return `  ${mark} ${l.order + 1}. ${l.label}: ${target}${key}  [${l.source}]`;
+  });
+}
+function embeddingChainVerdict(diagnosis) {
+  if (diagnosis.disabled) return "disabled (BB_EMBEDDING_DISABLED) \u2014 local word vectors only";
+  if (diagnosis.remoteReady) return diagnosis.fallbackConfigured ? "remote ready (primary + fallback)" : "remote ready";
+  return "remote NOT usable \u2014 semantic search degrades to local word vectors";
+}
+var LOCAL_DIMENSION = LOCAL_VECTOR_DIMENSION;
+
+// src/setup/setup-show.ts
+function readJsonSafe(p) {
+  try {
+    if (!existsSync(p)) return null;
+    return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function fileMode(p) {
+  try {
+    return statSync(p).mode & 511;
+  } catch {
+    return void 0;
+  }
+}
+function completeTier(tier, baseURL, model, key, file, skippedMarker) {
+  const present = baseURL !== void 0 || model !== void 0 || key !== void 0 || skippedMarker === true;
+  const complete = typeof baseURL === "string" && baseURL.length > 0 && typeof model === "string" && model.length > 0;
+  const missing = [];
+  if (!baseURL) missing.push("base URL");
+  if (!model) missing.push("model");
+  return {
+    tier,
+    present,
+    complete,
+    baseURL: typeof baseURL === "string" ? baseURL : void 0,
+    model: typeof model === "string" ? model : void 0,
+    keyFingerprint: typeof key === "string" && key.length > 0 ? fingerprintKey(key) : void 0,
+    file,
+    fileMode: file ? fileMode(file) : void 0,
+    incompleteReason: present && !complete ? `missing: ${missing.join(" + ")}` : void 0
+  };
+}
+function describeEmbeddingConfig(cwd = process.cwd(), env = process.env, dataDir = bbDataDir()) {
+  const globalFile = path.join(dataDir, "config.json");
+  const global = readJsonSafe(globalFile);
+  const projectFile = path.join(cwd, "bb.json");
+  const project = readJsonSafe(projectFile);
+  const envTier = completeTier(
+    "env",
+    env.BB_EMBEDDING_BASE_URL,
+    env.BB_EMBEDDING_MODEL,
+    env.BB_EMBEDDING_API_KEY
+  );
+  const globalTier = completeTier(
+    "global",
+    global?.embedding_base_url,
+    global?.embedding_model,
+    global?.embedding_api_key,
+    globalFile,
+    global?.setup_skipped === true
+  );
+  if (global && global.setup_skipped === true) globalTier.skippedMarker = true;
+  const projectTier = completeTier(
+    "project",
+    project?.embedding_base_url,
+    project?.embedding_model,
+    project?.embedding_api_key,
+    projectFile
+  );
+  const tiers = [envTier, globalTier, projectTier];
+  const winningTier = tiers.find((t) => t.complete);
+  const state = {
+    winner: winningTier?.tier ?? "none",
+    configured: Boolean(winningTier),
+    tiers
+  };
+  state.diagnosis = buildEmbeddingDiagnosis({ state, env });
+  return state;
+}
+function renderSetupShow(state) {
+  const lines = [];
+  lines.push("bb \u2014 embedding configuration");
+  lines.push("Precedence: env > ~/.bb/config.json > bb.json");
+  lines.push("");
+  const tierLabel = { env: "env", global: "global", project: "project" };
+  for (const t of state.tiers) {
+    const label = tierLabel[t.tier].padEnd(7);
+    if (!t.present) {
+      lines.push(`${label}: \u2014 (not set)`);
+      continue;
+    }
+    if (!t.complete) {
+      const key2 = t.keyFingerprint ? ` (key: \u2022\u2022\u2022\u2022${t.keyFingerprint})` : "";
+      const skipped = t.skippedMarker ? " \xB7 wizard skipped" : "";
+      lines.push(`${label}: \u2717 ${t.incompleteReason ?? "incomplete"}${key2}${skipped}`);
+      continue;
+    }
+    const key = t.keyFingerprint ? `key: \u2022\u2022\u2022\u2022${t.keyFingerprint}` : "key: none";
+    let line = `${label}: \u2713 ${t.baseURL} \xB7 ${t.model} \xB7 ${key}`;
+    if (t.fileMode !== void 0 && t.fileMode !== 384) {
+      line += ` \xB7 mode: ${t.fileMode.toString(8)} (expected: 600 \u2014 fix with bb doctor)`;
+    } else if (t.fileMode !== void 0) {
+      line += ` \xB7 mode: 600`;
+    }
+    if (t.skippedMarker) line += " \xB7 wizard skipped";
+    lines.push(line);
+  }
+  lines.push("");
+  if (state.configured) {
+    const w = state.winner;
+    lines.push(`Winner: ${tierLabel[w]}`);
+  } else {
+    lines.push("Winner: none \u2014 semantic search will use local vectors (weaker). Setup: bb setup");
+  }
+  const diagnosis = state.diagnosis;
+  if (diagnosis) {
+    lines.push("");
+    lines.push(`Chain: ${embeddingChainVerdict(diagnosis)}`);
+    for (const line of renderChainSummary(diagnosis)) lines.push(line);
+    const problems = diagnosis.problems.filter((p) => !/^No embedding provider is configured/.test(p.message));
+    for (const p of problems) {
+      const varName = p.envVar ? `${p.envVar}: ` : "";
+      lines.push(`  ! ${varName}${p.message}`);
+    }
+    for (const f of diagnosis.observedFailures) {
+      lines.push(`  \u2717 ${f.status} ${f.kind} from ${f.baseURL} \u2014 ${f.advice}`);
+    }
+    if (diagnosis.tierOrderDisagreement) {
+      lines.push(`  ! ${diagnosis.tierOrderDisagreement.detail}`);
+    }
+  }
+  return lines.join("\n") + "\n";
+}
+
+export {
+  buildEmbeddingDiagnosis,
+  renderChainSummary,
+  embedding_diagnosis_exports,
+  describeEmbeddingConfig,
+  renderSetupShow
+};

package/dist/chunk-KAET47ZL.js

@@ -0,0 +1,125 @@
+// src/ast/types.ts
+var RelationshipType = /* @__PURE__ */ ((RelationshipType2) => {
+  RelationshipType2["Calls"] = "calls";
+  RelationshipType2["Extends"] = "extends";
+  RelationshipType2["Implements"] = "implements";
+  RelationshipType2["Uses"] = "uses";
+  RelationshipType2["Imports"] = "imports";
+  RelationshipType2["Exports"] = "exports";
+  RelationshipType2["Contains"] = "contains";
+  RelationshipType2["References"] = "references";
+  RelationshipType2["Overrides"] = "overrides";
+  RelationshipType2["Instantiates"] = "instantiates";
+  RelationshipType2["Decorates"] = "decorates";
+  RelationshipType2["Renders"] = "renders";
+  RelationshipType2["MixesIn"] = "mixes_in";
+  RelationshipType2["PartOf"] = "part_of";
+  RelationshipType2["Call"] = "calls";
+  RelationshipType2["Inheritance"] = "extends";
+  RelationshipType2["Implementation"] = "implements";
+  RelationshipType2["Dependency"] = "uses";
+  RelationshipType2["Override"] = "overrides";
+  RelationshipType2["Composition"] = "contains";
+  RelationshipType2["Provides"] = "exports";
+  RelationshipType2["Related"] = "references";
+  return RelationshipType2;
+})(RelationshipType || {});
+var BINDING_SEP = "\0";
+
+// src/util/source-text.ts
+var BOMS = [
+  { bytes: [0, 0, 254, 255], encoding: "utf32be", bomLength: 4 },
+  { bytes: [255, 254, 0, 0], encoding: "utf32le", bomLength: 4 },
+  { bytes: [239, 187, 191], encoding: "utf8-bom", bomLength: 3 },
+  { bytes: [254, 255], encoding: "utf16be", bomLength: 2 },
+  { bytes: [255, 254], encoding: "utf16le", bomLength: 2 }
+];
+function decodeUtf32le(buf) {
+  const groups = Math.floor(buf.length / 4);
+  if (groups === 0) return "";
+  const units = new Array(groups * 2);
+  let n = 0;
+  for (let i = 0; i < groups; i++) {
+    const o = i * 4;
+    const cp = (buf[o] | buf[o + 1] << 8 | buf[o + 2] << 16 | buf[o + 3] << 24) >>> 0;
+    if (cp > 65535) {
+      const v = cp - 65536;
+      units[n++] = 55296 + (v >> 10);
+      units[n++] = 56320 + (v & 1023);
+    } else {
+      units[n++] = cp;
+    }
+  }
+  let out = "";
+  const CHUNK = 4096;
+  for (let i = 0; i < n; i += CHUNK) {
+    out += String.fromCharCode(...units.slice(i, Math.min(i + CHUNK, n)));
+  }
+  return out;
+}
+function swapGroups(buf, width) {
+  const out = Buffer.from(buf);
+  for (let i = 0; i + width <= out.length; i += width) {
+    for (let a = 0, b = width - 1; a < b; a++, b--) {
+      const t = out[i + a];
+      out[i + a] = out[i + b];
+      out[i + b] = t;
+    }
+  }
+  return out;
+}
+function startsWith(buf, bytes) {
+  if (buf.length < bytes.length) return false;
+  for (let i = 0; i < bytes.length; i++) if (buf[i] !== bytes[i]) return false;
+  return true;
+}
+function sniffUtf16(buf) {
+  const limit = Math.min(buf.length, 512);
+  if (limit < 4) return null;
+  let evenNuls = 0;
+  let oddNuls = 0;
+  let pairs = 0;
+  for (let i = 0; i + 1 < limit; i += 2) {
+    pairs++;
+    if (buf[i] === 0) evenNuls++;
+    if (buf[i + 1] === 0) oddNuls++;
+  }
+  if (pairs === 0) return null;
+  if (oddNuls / pairs > 0.7 && evenNuls / pairs < 0.1) return "utf16le";
+  if (evenNuls / pairs > 0.7 && oddNuls / pairs < 0.1) return "utf16be";
+  return null;
+}
+function decodeSourceText(buf) {
+  for (const bom of BOMS) {
+    if (!startsWith(buf, bom.bytes)) continue;
+    const body = buf.subarray(bom.bomLength);
+    switch (bom.encoding) {
+      case "utf8-bom":
+        return { text: body.toString("utf8"), encoding: "utf8-bom", hadBom: true, inferred: false };
+      case "utf16be":
+        return { text: swapGroups(body, 2).toString("utf16le"), encoding: "utf16be", hadBom: true, inferred: false };
+      case "utf32be":
+        return { text: decodeUtf32le(swapGroups(body, 4)), encoding: "utf32be", hadBom: true, inferred: false };
+      case "utf32le":
+        return { text: decodeUtf32le(body), encoding: "utf32le", hadBom: true, inferred: false };
+      default:
+        return { text: body.toString("utf16le"), encoding: "utf16le", hadBom: true, inferred: false };
+    }
+  }
+  const sniffed = sniffUtf16(buf);
+  if (sniffed) {
+    return {
+      text: sniffed === "utf16le" ? buf.toString("utf16le") : swapGroups(buf, 2).toString("utf16le"),
+      encoding: sniffed,
+      hadBom: false,
+      inferred: true
+    };
+  }
+  return { text: buf.toString("utf8"), encoding: "utf8", hadBom: false, inferred: false };
+}
+
+export {
+  RelationshipType,
+  BINDING_SEP,
+  decodeSourceText
+};