@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/chunk-SK6YVHFZ.js

@@ -0,0 +1,211 @@
+import {
+  bbWasmCandidates,
+  bbWasmDirs
+} from "./chunk-2BSKD7O3.js";
+
+// src/util/wasm.ts
+import { createRequire } from "module";
+import { existsSync, readFileSync, readdirSync } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+var require2 = createRequire(import.meta.url);
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var _wtsModule = null;
+var _wasmRegistry = {};
+var _wasiShimInstalled = false;
+function installWasiShim() {
+  if (_wasiShimInstalled) return;
+  _wasiShimInstalled = true;
+  let currentImports = null;
+  const memOf = () => currentImports?.env?.memory;
+  const view = () => {
+    const mem = memOf();
+    return mem ? new DataView(mem.buffer) : null;
+  };
+  const writeInt32 = (ptr, value) => {
+    const v = view();
+    if (v && Number.isFinite(ptr)) v.setInt32(ptr, value, true);
+  };
+  const writeBigInt = (ptr, value) => {
+    const v = view();
+    if (v && Number.isFinite(ptr)) v.setBigUint64(ptr, value, true);
+  };
+  const wasi = {
+    clock_time_get: (_clockId, _precisionPtr, timePtr) => {
+      writeBigInt(timePtr, BigInt(Date.now()) * 1000000n);
+      return 0;
+    },
+    proc_exit: () => {
+    },
+    fd_write: (_fd, _iov, _iovcnt, pnum) => {
+      writeInt32(pnum, 0);
+      return 0;
+    },
+    fd_read: () => -1,
+    fd_close: () => 0,
+    fd_seek: () => -1,
+    fd_fdstat_get: () => -1,
+    fd_fdstat_set_flags: () => -1,
+    fd_prestat_get: () => -1,
+    fd_prestat_dir_name: () => -1,
+    fd_sync: () => -1,
+    random_get: (buf, len) => {
+      const v = view();
+      if (v) for (let i = 0; i < len; i++) v.setUint8(buf + i, Math.floor(Math.random() * 256));
+      return 0;
+    },
+    environ_get: () => 0,
+    environ_sizes_get: (countPtr, sizePtr) => {
+      writeInt32(countPtr, 0);
+      writeInt32(sizePtr, 0);
+      return 0;
+    },
+    args_get: () => 0,
+    args_sizes_get: (countPtr, sizePtr) => {
+      writeInt32(countPtr, 0);
+      writeInt32(sizePtr, 0);
+      return 0;
+    },
+    sched_yield: () => 0,
+    poll_oneoff: () => 0,
+    path_open: () => -1,
+    path_filestat_get: () => -1,
+    path_filestat_set_times: () => -1,
+    path_create_directory: () => -1,
+    path_remove_directory: () => -1,
+    path_unlink_file: () => -1,
+    path_rename: () => -1,
+    path_link: () => -1,
+    path_symlink: () => -1,
+    path_readlink: () => -1,
+    path_filestat_set_size: () => -1,
+    clock_res_get: (_clockId, resPtr) => {
+      writeBigInt(resPtr, 1000000n);
+      return 0;
+    }
+  };
+  const patchImports = (imports) => {
+    if (!imports || typeof imports !== "object") return imports;
+    currentImports = imports;
+    if (imports.wasi_snapshot_preview1) {
+      imports.wasi_snapshot_preview1 = { ...imports.wasi_snapshot_preview1, ...wasi };
+    }
+    return imports;
+  };
+  const origInstantiate = WebAssembly.instantiate;
+  const origInstantiateStreaming = WebAssembly.instantiateStreaming;
+  WebAssembly.instantiate = async (bytes, imports) => {
+    if (imports) imports = patchImports(imports);
+    return origInstantiate.call(WebAssembly, bytes, imports);
+  };
+  WebAssembly.instantiateStreaming = async (resp, imports) => {
+    if (imports) imports = patchImports(imports);
+    return origInstantiateStreaming.call(WebAssembly, resp, imports);
+  };
+}
+function tryLoadWasm(name) {
+  if (_wasmRegistry[name]) return;
+  const paths = bbWasmCandidates(dirname(fileURLToPath(import.meta.url)), name);
+  for (const p of paths) {
+    if (existsSync(p)) {
+      try {
+        _wasmRegistry[name] = new Uint8Array(readFileSync(p));
+        return;
+      } catch {
+      }
+    }
+  }
+}
+async function ensureWasmRegistry() {
+  const dirs = bbWasmDirs(__dirname);
+  for (const wasmDir of dirs) {
+    if (existsSync(wasmDir)) {
+      try {
+        const files = (await import("fs")).readdirSync(wasmDir);
+        for (const f of files) {
+          if (f.endsWith(".wasm") && !_wasmRegistry[f]) {
+            try {
+              _wasmRegistry[f] = new Uint8Array(readFileSync(join(wasmDir, f)));
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+}
+async function loadWebTreeSitter() {
+  if (!_wtsModule) {
+    installWasiShim();
+    _wtsModule = await import("web-tree-sitter");
+    const initFn = _wtsModule.default?.init || _wtsModule.init;
+    if (initFn) {
+      const coreName = "tree-sitter.wasm";
+      const coreBytes = hasWasmInRegistry(coreName);
+      const coreAbs = resolveWasmAsset(coreName);
+      const initOptions = {};
+      if (coreBytes) initOptions.wasmBinary = coreBytes;
+      if (coreAbs !== coreName) initOptions.locateFile = () => coreAbs;
+      await initFn(initOptions);
+    }
+  }
+  return _wtsModule;
+}
+function resolveWasmAsset(name) {
+  const wasmName = name.split("/").pop() || name;
+  const paths = bbWasmCandidates(dirname(fileURLToPath(import.meta.url)), wasmName);
+  for (const p of paths) {
+    if (existsSync(p)) return p;
+  }
+  return name;
+}
+function hasWasmInRegistry(name) {
+  const wasmName = name.split("/").pop() || name;
+  tryLoadWasm(wasmName);
+  if (_wasmRegistry[wasmName]) return _wasmRegistry[wasmName];
+  if (_wasmRegistry[name]) return _wasmRegistry[name];
+  const paths = bbWasmCandidates(dirname(fileURLToPath(import.meta.url)), wasmName);
+  for (const p of paths) {
+    if (existsSync(p)) {
+      try {
+        const data = new Uint8Array(readFileSync(p));
+        _wasmRegistry[wasmName] = data;
+        return data;
+      } catch {
+      }
+    }
+  }
+  return void 0;
+}
+function isWasmRegistryLoaded() {
+  return false;
+}
+(function _autoLoadWasm() {
+  const dirs = bbWasmDirs(__dirname);
+  for (const wasmDir of dirs) {
+    if (existsSync(wasmDir)) {
+      try {
+        const files = readdirSync(wasmDir);
+        for (const f of files) {
+          if (f.endsWith(".wasm") && !_wasmRegistry[f]) {
+            try {
+              _wasmRegistry[f] = new Uint8Array(readFileSync(join(wasmDir, f)));
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }
+  }
+})();
+
+export {
+  ensureWasmRegistry,
+  loadWebTreeSitter,
+  resolveWasmAsset,
+  hasWasmInRegistry,
+  isWasmRegistryLoaded
+};

package/dist/chunk-SM7RFQRO.js

@@ -0,0 +1,214 @@
+import {
+  isTestFileCandidate
+} from "./chunk-L5TDYKYK.js";
+import {
+  BrainFileTable,
+  BrainSymbolTable
+} from "./chunk-ROMM6KMC.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// src/ast/analysis-exclusions.ts
+var analysis_exclusions_exports = {};
+__export(analysis_exclusions_exports, {
+  AnalysisExclusions: () => analysis_exclusions_exports,
+  NON_CODE_LANGUAGES: () => NON_CODE_LANGUAGES,
+  analysisPathScopeSQL: () => analysisPathScopeSQL,
+  analysisScopeConditions: () => analysisScopeConditions,
+  analysisSymbolNameConditions: () => analysisSymbolNameConditions,
+  analysisSymbolNameScopeSQL: () => analysisSymbolNameScopeSQL,
+  isAnalysisExcluded: () => isAnalysisExcluded,
+  isHardNoisePath: () => isHardNoisePath,
+  isIndexArtifactName: () => isIndexArtifactName,
+  isIndexArtifactNameStrict: () => isIndexArtifactNameStrict,
+  isNoiseSymbolName: () => isNoiseSymbolName,
+  isNonCodeLanguage: () => isNonCodeLanguage,
+  isTestPath: () => isTestPath,
+  nonCodeLanguageSQL: () => nonCodeLanguageSQL
+});
+import { notLike, sql } from "drizzle-orm";
+var NOISE_DIR_SEGMENTS = /* @__PURE__ */ new Set([
+  "baselines",
+  "snapshots",
+  "__snapshots__",
+  "__generated__",
+  "generated",
+  "gen",
+  "fixtures",
+  "node_modules",
+  "vendor",
+  "dist",
+  "build",
+  "coverage",
+  "__pycache__"
+]);
+var TEST_DIR_SEGMENTS = /* @__PURE__ */ new Set(["test", "tests", "__tests__", "spec", "specs", "e2e"]);
+var NOISE_FILE_PATTERNS = [
+  /\.d\.[a-z]+$/,
+  /\.(min|-min)\.[a-z]+$/,
+  /\.(bundle|chunk)\.[a-z]+$/,
+  /\.map$/,
+  /\.(generated|gen)\.[a-z]+$/i,
+  /\.g\.(cs|ts|js|fs)$/i
+  // NOTE: .json is deliberately absent — the JSON analyzer is a verified
+  // contract (M12.34, P/R 1.000) whose module/class/property symbols must
+  // reach the read surface. Genuinely noisy JSON (package-lock.json,
+  // openapi.json, schema.json, *.min.json, Az.*.json, ...) is already
+  // excluded at INDEX time by ParallelIndexerConfig.skipPatterns.
+];
+var EXCLUDED_FILE_LIKES = [
+  "%.d.ts",
+  "%.d.mts",
+  "%.d.cts",
+  "%.min.%",
+  "%-min.%",
+  "%.bundle.%",
+  "%.chunk.%",
+  "%.generated.%",
+  "%.map"
+];
+function allExcludedSegments() {
+  return Array.from(/* @__PURE__ */ new Set([...NOISE_DIR_SEGMENTS, ...TEST_DIR_SEGMENTS]));
+}
+function isHardNoisePath(relativePath) {
+  const lower = relativePath.toLowerCase();
+  if (NOISE_FILE_PATTERNS.some((pattern) => pattern.test(lower))) return true;
+  return lower.split("/").some((segment) => NOISE_DIR_SEGMENTS.has(segment));
+}
+function isTestPath(relativePath) {
+  return isTestFileCandidate(relativePath);
+}
+var NON_CODE_LANGUAGES = /* @__PURE__ */ new Set([
+  "markdown",
+  "yaml",
+  "toml",
+  "json",
+  "xml",
+  "css",
+  "scss",
+  "less",
+  "html",
+  "htm",
+  "vue",
+  "svelte",
+  "ini",
+  "cfg",
+  "conf",
+  "properties",
+  "env",
+  "csv",
+  "tsv",
+  "text",
+  "plaintext",
+  "rst",
+  "tex",
+  "bib",
+  "org",
+  "adoc",
+  "asciidoc"
+]);
+function isNonCodeLanguage(language) {
+  return NON_CODE_LANGUAGES.has((language ?? "").toLowerCase());
+}
+function nonCodeLanguageSQL(fileAlias) {
+  const params = [...NON_CODE_LANGUAGES];
+  const placeholders = params.map(() => "?").join(",");
+  return { sql: `LOWER(COALESCE(${fileAlias}.language, '')) NOT IN (${placeholders})`, params };
+}
+function isAnalysisExcluded(relativePath) {
+  return isHardNoisePath(relativePath) || isTestPath(relativePath);
+}
+function isNoiseSymbolName(name) {
+  if (!name) return true;
+  if (name.length > 500) return true;
+  if (/^(anonymous|anon|unnamed)[_-]/i.test(name)) return true;
+  if (/^(block|lambda)[_-]\d+/i.test(name)) return true;
+  if (/^object_\d+$/.test(name)) return true;
+  if (/^(this|global|window|super|arguments|undefined|null)$/.test(name)) return true;
+  if (name.startsWith("/") && name.includes("/")) return true;
+  return false;
+}
+function isIndexArtifactName(name) {
+  if (!name) return true;
+  if (name.length > 500) return true;
+  if (/^(anonymous|anon|unnamed)[_-]/i.test(name)) return true;
+  if (/^(block|lambda)[_-]\d+/i.test(name)) return true;
+  if (/^object_\d+$/.test(name)) return true;
+  if (/^(this|global|window|super|arguments|undefined|null)$/.test(name)) return true;
+  if (name.startsWith("/") && name.includes("/")) return true;
+  return false;
+}
+function isIndexArtifactNameStrict(name) {
+  if (isIndexArtifactName(name)) return true;
+  if (name.includes('"') || name.includes("'")) return true;
+  if (name.startsWith("(")) return true;
+  if (/^[+-]?[.\d]/.test(name)) return true;
+  if (name.includes(" ") && !name.startsWith("operator")) return true;
+  return !/[\p{L}]/u.test(name);
+}
+function analysisScopeConditions() {
+  return [
+    sql`COALESCE(${BrainFileTable.is_test_file}, 0) = 0`,
+    ...allExcludedSegments().flatMap((segment) => [
+      notLike(BrainFileTable.relative_path, `${segment}/%`),
+      notLike(BrainFileTable.relative_path, `%/${segment}/%`)
+    ]),
+    ...EXCLUDED_FILE_LIKES.map((pattern) => notLike(BrainFileTable.relative_path, pattern))
+  ];
+}
+function analysisPathScopeSQL(...fileAliases) {
+  const clauses = [];
+  for (const alias of fileAliases) {
+    clauses.push(`COALESCE(${alias}.is_test_file, 0) = 0`);
+    for (const segment of allExcludedSegments()) {
+      clauses.push(`${alias}.relative_path NOT LIKE '${segment}/%'`);
+      clauses.push(`${alias}.relative_path NOT LIKE '%/${segment}/%'`);
+    }
+    for (const pattern of EXCLUDED_FILE_LIKES) {
+      clauses.push(`${alias}.relative_path NOT LIKE '${pattern}'`);
+    }
+  }
+  return clauses.join(" AND ");
+}
+var NOISE_NAME_LIKES = ["anonymous%", "anon_%", "unnamed_%", "block_%", "lambda_%", "/%"];
+var NOISE_NAME_GLOBS = ["object_[0-9]*"];
+var NOISE_KEYWORD_NAMES = ["this", "global", "window", "super", "arguments", "undefined", "null"];
+function analysisSymbolNameConditions() {
+  return [
+    ...NOISE_NAME_LIKES.map((pattern) => notLike(BrainSymbolTable.name, pattern)),
+    ...NOISE_NAME_GLOBS.map((pattern) => sql`${BrainSymbolTable.name} NOT GLOB ${pattern}`),
+    sql`${BrainSymbolTable.name} NOT IN (${sql.join(NOISE_KEYWORD_NAMES.map((k) => sql`${k}`), sql`, `)})`,
+    sql`LENGTH(${BrainSymbolTable.name}) < 200`,
+    // Symbols without a real location can't be jumped to — indexer artifacts.
+    sql`COALESCE(${BrainSymbolTable.line_start}, 0) > 0`,
+    // Absolute paths indexed as names (indexer artifact).
+    notLike(BrainSymbolTable.name, "/%/%")
+  ];
+}
+function analysisSymbolNameScopeSQL(symbolAlias) {
+  const clauses = NOISE_NAME_LIKES.map((pattern) => `${symbolAlias}.name NOT LIKE '${pattern}'`);
+  clauses.push(...NOISE_NAME_GLOBS.map((pattern) => `${symbolAlias}.name NOT GLOB '${pattern}'`));
+  clauses.push(`${symbolAlias}.name NOT IN (${NOISE_KEYWORD_NAMES.map((k) => `'${k}'`).join(",")})`);
+  clauses.push(`LENGTH(${symbolAlias}.name) < 200`);
+  clauses.push(`COALESCE(${symbolAlias}.line_start, 0) > 0`);
+  clauses.push(`${symbolAlias}.name NOT LIKE '/%/%'`);
+  return clauses.join(" AND ");
+}
+
+export {
+  isHardNoisePath,
+  isTestPath,
+  NON_CODE_LANGUAGES,
+  isNonCodeLanguage,
+  nonCodeLanguageSQL,
+  isAnalysisExcluded,
+  isNoiseSymbolName,
+  isIndexArtifactName,
+  isIndexArtifactNameStrict,
+  analysisScopeConditions,
+  analysisPathScopeSQL,
+  analysisSymbolNameConditions,
+  analysisSymbolNameScopeSQL,
+  analysis_exclusions_exports
+};

package/dist/chunk-UGR4QIGS.js

@@ -0,0 +1,67 @@
+import {
+  bbDataDir
+} from "./chunk-2BSKD7O3.js";
+
+// src/config/config.ts
+import path from "path";
+import { existsSync, readFileSync } from "fs";
+var cached = null;
+function readJson(p) {
+  try {
+    if (existsSync(p)) return JSON.parse(readFileSync(p, "utf8"));
+  } catch {
+  }
+  return null;
+}
+function resolveEmbeddingConfig(fileConfig) {
+  const pick = (envVar, fileKey, fallback) => {
+    const env = process.env[envVar];
+    if (env) return [env, `env:${envVar}`];
+    const file = fileConfig[fileKey];
+    if (typeof file === "string" && file) return [file, `file:${fileKey}`];
+    return [fallback, "default"];
+  };
+  const [baseURL, baseURLSrc] = pick("BB_EMBEDDING_BASE_URL", "embedding_base_url", "https://api.openai.com/v1");
+  const [model, modelSrc] = pick("BB_EMBEDDING_MODEL", "embedding_model", "text-embedding-3-small");
+  const [apiKey, apiKeySrc] = pick("BB_EMBEDDING_API_KEY", "embedding_api_key", "");
+  return {
+    baseURL: baseURL.replace(/\/+$/, ""),
+    model,
+    apiKey,
+    configured: baseURLSrc !== "default" && modelSrc !== "default",
+    sources: { baseURL: baseURLSrc, model: modelSrc, apiKey: apiKeySrc }
+  };
+}
+function withEnvironmentOverrides(config) {
+  const eff = resolveEmbeddingConfig(config);
+  const merged = { ...config };
+  if (eff.configured) {
+    merged.embedding_base_url = eff.baseURL;
+    merged.embedding_model = eff.model;
+    merged.embedding_api_key = eff.apiKey;
+  }
+  if (process.env.BB_PROVIDER) merged.provider = process.env.BB_PROVIDER;
+  return merged;
+}
+var Config;
+((Config2) => {
+  async function get() {
+    if (cached) return withEnvironmentOverrides(cached);
+    const home = readJson(path.join(bbDataDir(), "config.json"));
+    const local = readJson(path.join(process.cwd(), "bb.json"));
+    const explicit = process.env.BB_CONFIG_FILE ? readJson(path.resolve(process.env.BB_CONFIG_FILE)) : null;
+    const merged = { ...home ?? {}, ...local ?? {}, ...explicit ?? {} };
+    cached = merged;
+    return withEnvironmentOverrides(merged);
+  }
+  Config2.get = get;
+  function clearCache() {
+    cached = null;
+  }
+  Config2.clearCache = clearCache;
+})(Config || (Config = {}));
+
+export {
+  resolveEmbeddingConfig,
+  Config
+};