@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/cli/index.js

@@ -0,0 +1,37 @@
+import {
+  runCli
+} from "../chunk-ZE2LG76D.js";
+import "../chunk-22V37YTK.js";
+import "../chunk-DWKXZ6IF.js";
+import "../chunk-2RRBMNBQ.js";
+import "../chunk-UQNQZXHY.js";
+import "../chunk-ZETTGPAW.js";
+import "../chunk-4H22TLOT.js";
+import "../chunk-B5GEAAYF.js";
+import "../chunk-7AN7U5IZ.js";
+import "../chunk-UGR4QIGS.js";
+import "../chunk-GEFFO6O2.js";
+import "../chunk-NO3U3FJQ.js";
+import "../chunk-DYM4FQEE.js";
+import {
+  getProjectId
+} from "../chunk-DIYAGQJL.js";
+import "../chunk-UUNHHX4M.js";
+import "../chunk-WIG36E67.js";
+import "../chunk-QLK6ED4Q.js";
+import "../chunk-QKTRECYS.js";
+import "../chunk-3ZTOHHSW.js";
+import "../chunk-BQ3OVQ3P.js";
+import "../chunk-SK6YVHFZ.js";
+import "../chunk-2BSKD7O3.js";
+import "../chunk-KAET47ZL.js";
+import "../chunk-KCDECRJY.js";
+import "../chunk-D2Q4Y47A.js";
+import "../chunk-SM7RFQRO.js";
+import "../chunk-L5TDYKYK.js";
+import "../chunk-ROMM6KMC.js";
+import "../chunk-MLKGABMK.js";
+export {
+  getProjectId,
+  runCli
+};

package/dist/config-HZAAYDP3.js

@@ -0,0 +1,10 @@
+import {
+  Config,
+  resolveEmbeddingConfig
+} from "./chunk-UGR4QIGS.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-MLKGABMK.js";
+export {
+  Config,
+  resolveEmbeddingConfig
+};

package/dist/content-search-7XIP555Q.js

@@ -0,0 +1,593 @@
+import {
+  tokenizeForEmbedding
+} from "./chunk-7AN7U5IZ.js";
+import {
+  checkResultsFreshness
+} from "./chunk-QLK6ED4Q.js";
+import {
+  BrainDatabase
+} from "./chunk-QKTRECYS.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-2BSKD7O3.js";
+import {
+  analysis_exclusions_exports
+} from "./chunk-SM7RFQRO.js";
+import "./chunk-L5TDYKYK.js";
+import "./chunk-ROMM6KMC.js";
+import "./chunk-MLKGABMK.js";
+
+// src/intelligence/search/content-search.ts
+var fts5Available = null;
+var contentFtsBuilds = /* @__PURE__ */ new Map();
+var CONTENT_FTS_TABLE = "brain_symbol_content_fts";
+var CONTENT_FTS_META = "brain_symbol_content_fts_meta";
+function detectFts5(raw) {
+  if (fts5Available !== null) return fts5Available;
+  try {
+    raw.exec("CREATE VIRTUAL TABLE IF NOT EXISTS temp.__bb_fts_probe USING fts5(x)");
+    raw.exec("DROP TABLE IF EXISTS temp.__bb_fts_probe");
+    fts5Available = true;
+  } catch {
+    fts5Available = false;
+  }
+  return fts5Available;
+}
+function tableExists(raw, name) {
+  try {
+    return raw.prepare("SELECT 1 AS present FROM sqlite_master WHERE type = 'table' AND name = ?").get(name) != null;
+  } catch {
+    return false;
+  }
+}
+function contentFtsSchema(raw) {
+  raw.exec(
+    `CREATE VIRTUAL TABLE IF NOT EXISTS ${CONTENT_FTS_TABLE} USING fts5(
+      symbol_id UNINDEXED, project_id UNINDEXED, name, qualified_name, docstring,
+      tokenize='trigram'
+    );
+    CREATE TABLE IF NOT EXISTS ${CONTENT_FTS_META} (
+      project_id TEXT PRIMARY KEY NOT NULL,
+      symbol_count INTEGER NOT NULL,
+      max_updated INTEGER NOT NULL
+    );
+    CREATE TRIGGER IF NOT EXISTS bb_content_fts_symbol_insert
+      AFTER INSERT ON brain_symbol
+      BEGIN DELETE FROM ${CONTENT_FTS_META} WHERE project_id = NEW.project_id; END;
+    CREATE TRIGGER IF NOT EXISTS bb_content_fts_symbol_update
+      AFTER UPDATE ON brain_symbol
+      BEGIN
+        DELETE FROM ${CONTENT_FTS_META} WHERE project_id = OLD.project_id;
+        DELETE FROM ${CONTENT_FTS_META} WHERE project_id = NEW.project_id;
+      END;
+    CREATE TRIGGER IF NOT EXISTS bb_content_fts_symbol_delete
+      AFTER DELETE ON brain_symbol
+      BEGIN DELETE FROM ${CONTENT_FTS_META} WHERE project_id = OLD.project_id; END;`
+  );
+}
+async function ensureContentFts(raw, projectId) {
+  if (!detectFts5(raw)) return false;
+  try {
+    if (!tableExists(raw, CONTENT_FTS_META) || !tableExists(raw, CONTENT_FTS_TABLE)) return false;
+    const marker = raw.prepare(
+      `SELECT symbol_count AS symbolCount, max_updated AS maxUpdated FROM ${CONTENT_FTS_META} WHERE project_id = ?`
+    ).get(projectId);
+    return marker != null;
+  } catch {
+    return false;
+  }
+}
+async function rebuildContentSearchIndex(projectId) {
+  const key = String(projectId);
+  const active = contentFtsBuilds.get(key);
+  if (active) {
+    await active;
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    const row = raw.prepare(`SELECT symbol_count AS symbolCount, max_updated AS maxUpdated FROM ${CONTENT_FTS_META} WHERE project_id=?`).get(projectId);
+    return { indexed: Number(row?.symbolCount || 0), symbolCount: Number(row?.symbolCount || 0), maxUpdated: Number(row?.maxUpdated || 0) };
+  }
+  const build = Promise.resolve().then(async () => {
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    if (!detectFts5(raw)) throw new Error("SQLite FTS5 is unavailable");
+    contentFtsSchema(raw);
+    const snapshot = raw.prepare(
+      "SELECT COUNT(*) AS symbolCount, COALESCE(MAX(time_updated), 0) AS maxUpdated FROM brain_symbol WHERE project_id = ? AND COALESCE(line_start, 0) > 0 AND name NOT LIKE '/%/%'"
+    ).get(projectId);
+    const rebuild = raw.transaction(() => {
+      raw.prepare(`DELETE FROM ${CONTENT_FTS_TABLE} WHERE project_id = ?`).run(projectId);
+      const insert = raw.prepare(`INSERT INTO ${CONTENT_FTS_TABLE} (symbol_id, project_id, name, qualified_name, docstring) VALUES (?, ?, ?, ?, ?)`);
+      const rows = raw.prepare("SELECT id, name, qualified_name AS qualifiedName, docstring FROM brain_symbol WHERE project_id = ? AND COALESCE(line_start, 0) > 0 AND name NOT LIKE '/%/%'").all(projectId);
+      for (const row of rows) insert.run(row.id, projectId, row.name, row.qualifiedName ?? "", row.docstring ?? "");
+      raw.prepare(`INSERT INTO ${CONTENT_FTS_META} (project_id, symbol_count, max_updated) VALUES (?, ?, ?) ON CONFLICT(project_id) DO UPDATE SET symbol_count=excluded.symbol_count, max_updated=excluded.max_updated`).run(projectId, snapshot.symbolCount, snapshot.maxUpdated);
+      return rows.length;
+    });
+    const indexed = rebuild();
+    return { indexed, symbolCount: snapshot.symbolCount, maxUpdated: snapshot.maxUpdated };
+  });
+  contentFtsBuilds.set(key, build.then(() => true));
+  try {
+    return await build;
+  } finally {
+    contentFtsBuilds.delete(key);
+  }
+}
+function ftsQuote(term) {
+  return '"' + term.split('"').join('""') + '"';
+}
+var LIKE_ESCAPE_CHAR = "\\";
+function escapeLike(fragment) {
+  return fragment.split(LIKE_ESCAPE_CHAR).join(LIKE_ESCAPE_CHAR + LIKE_ESCAPE_CHAR).split("%").join(LIKE_ESCAPE_CHAR + "%").split("_").join(LIKE_ESCAPE_CHAR + "_");
+}
+var LIKE_ESCAPE_CLAUSE = ` ESCAPE '${LIKE_ESCAPE_CHAR}'`;
+function firstLine(text) {
+  const line = text.split("\n").find((candidate) => candidate.trim().length > 0) ?? "";
+  return line.trim().slice(0, 100);
+}
+var GIANT_CORPUS_OFFSET = 25e3;
+var PHASE_CAP_MIN = 2e4;
+var PHASE_CAP_MAX = 2e5;
+var ID_JOIN_CHUNK = 500;
+function phaseCap(budget) {
+  return Math.min(PHASE_CAP_MAX, Math.max(PHASE_CAP_MIN, budget * 4));
+}
+function normalizePageSize(value) {
+  if (value === void 0 || value === null) return 100;
+  const n = Math.trunc(Number(value));
+  if (!Number.isFinite(n) || n < 0) return 100;
+  return n;
+}
+function normalizeOffset(value) {
+  if (value === void 0 || value === null) return 0;
+  const n = Math.trunc(Number(value));
+  if (!Number.isFinite(n) || n < 0) return 0;
+  return n;
+}
+async function searchContent(projectId, query, options = {}) {
+  const raw = await BrainDatabase.getRawInstance(projectId, { readonly: true });
+  const maxResults = normalizePageSize(options.maxResults);
+  const offset = normalizeOffset(options.offset);
+  const trimmed = String(query ?? "").trim();
+  if (!trimmed) return withMeta([], "content");
+  if (isGiantCorpus(raw, projectId)) {
+    return searchContentBounded(raw, projectId, trimmed, options, maxResults, offset);
+  }
+  return searchContentClassic(raw, projectId, trimmed, options, maxResults, offset, detectFts5(raw));
+}
+function isGiantCorpus(raw, projectId) {
+  const probe = raw.prepare(
+    "SELECT id FROM brain_symbol WHERE project_id = ? AND COALESCE(line_start, 0) > 0 AND name NOT LIKE ? LIMIT 1 OFFSET ?"
+  ).get(projectId, "/%/%", GIANT_CORPUS_OFFSET);
+  return probe != null;
+}
+async function searchContentClassic(raw, projectId, trimmed, options, maxResults, offset, fts5) {
+  const params = [projectId];
+  let filters = "";
+  if (options.languages?.length) {
+    filters += " AND f.language COLLATE NOCASE IN (" + options.languages.map(() => "?").join(",") + ")";
+    params.push(...options.languages);
+  }
+  if (options.symbolKind) {
+    filters += " AND s.symbol_type COLLATE NOCASE = ?";
+    params.push(options.symbolKind);
+  }
+  const corpus = raw.prepare(
+    "SELECT s.id, s.file_id AS fileId, s.name, s.qualified_name AS qualifiedName, s.docstring, s.source_text AS sourceText, s.symbol_type AS symbolType, COALESCE(s.line_start, 0) AS line, COALESCE(s.line_end, 0) AS lineEnd, COALESCE(s.complexity, 0) AS complexity, f.relative_path AS relativePath, f.path AS filePath, COALESCE(f.language, 'unknown') AS language FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id WHERE s.project_id = ? AND COALESCE(s.line_start, 0) > 0 AND s.name NOT LIKE '/%/%'" + filters
+  ).all(...params);
+  const usable = corpus.filter(
+    (row) => !analysis_exclusions_exports.isHardNoisePath(row.relativePath) && !analysis_exclusions_exports.isNoiseSymbolName(row.name)
+  );
+  const matched = matchContentRows(trimmed, usable);
+  const ranked = fts5 ? rankWithFts5(raw, trimmed, matched.rows) : sortByFieldWeight(trimmed, matched.rows);
+  const page = ranked.slice(offset, offset + maxResults);
+  const withBody = usable.filter((r) => !!r.sourceText).length;
+  return buildResults(raw, page, "content", maxResults, {
+    totalMatches: matched.rows.length,
+    // Only the terms route can exceed the cap, so this is the one place a
+    // content search truncates — and it reports it rather than looking complete.
+    truncated: matched.truncated,
+    matchMode: matched.mode,
+    ...matched.termMatch ? { termMatch: matched.termMatch } : {},
+    // Declared in the contract since the body column landed but never actually
+    // populated: a project indexed before it has no searchable body at all, so
+    // "nothing matched" there means something different from "nothing could
+    // match", and a caller cannot tell those apart without this.
+    bodyCoverage: { withBody, symbols: usable.length, ratio: usable.length ? withBody / usable.length : 1 }
+  });
+}
+var GIANT_TERM_BUDGET = 2;
+async function searchContentBounded(raw, projectId, trimmed, options, maxResults, offset) {
+  const byId = /* @__PURE__ */ new Map();
+  const bump = (rows, score) => {
+    for (const row of rows) {
+      if (analysis_exclusions_exports.isHardNoisePath(row.relativePath) || analysis_exclusions_exports.isNoiseSymbolName(row.name)) continue;
+      const existing = byId.get(row.id);
+      if (existing) existing.score += score;
+      else byId.set(row.id, { row, score });
+    }
+  };
+  const { sql: idFilterSql, params: idFilterParams } = languageClause(options);
+  const contentFtsReady = await ensureContentFts(raw, projectId);
+  const pageBudget = offset + maxResults;
+  const cap = phaseCap(pageBudget);
+  let truncated = false;
+  const sqlNeedleIds = (needleText) => {
+    const needle = "%" + escapeLike(needleText) + "%";
+    const ids = raw.prepare(
+      `SELECT id FROM brain_symbol WHERE project_id = ? AND COALESCE(line_start, 0) > 0 AND name NOT LIKE '/%/%' AND (name LIKE ? COLLATE NOCASE${LIKE_ESCAPE_CLAUSE} OR qualified_name LIKE ? COLLATE NOCASE${LIKE_ESCAPE_CLAUSE} OR docstring LIKE ? COLLATE NOCASE${LIKE_ESCAPE_CLAUSE} OR source_text LIKE ? COLLATE NOCASE${LIKE_ESCAPE_CLAUSE}) LIMIT ?`
+    ).all(projectId, needle, needle, needle, needle, cap);
+    if (ids.length >= cap) truncated = true;
+    return ids;
+  };
+  const deferPhrase = contentQueryTerms(trimmed).length > 0;
+  bump(selectJoined(raw, projectId, "s.name = ? COLLATE NOCASE" + idFilterSql, [trimmed, ...idFilterParams]), 3);
+  {
+    const rows = selectJoined(
+      raw,
+      projectId,
+      `s.name LIKE ? COLLATE NOCASE${LIKE_ESCAPE_CLAUSE}${idFilterSql} LIMIT ?`,
+      [escapeLike(trimmed) + "%", ...idFilterParams, cap]
+    );
+    if (rows.length >= cap) truncated = true;
+    bump(rows, 3);
+  }
+  {
+    const lowerNeedle = trimmed.toLowerCase();
+    const push = (rows) => {
+      for (const row of rows) {
+        const score = contentScore(row, lowerNeedle);
+        if (score > 0) bump([row], score);
+      }
+    };
+    let broadIds = [];
+    if (contentFtsReady && trimmed.length >= 3) {
+      const ftsQuery = ftsQuote(trimmed);
+      broadIds = raw.prepare(`SELECT symbol_id AS id FROM ${CONTENT_FTS_TABLE} WHERE ${CONTENT_FTS_TABLE} MATCH ? AND project_id = ? LIMIT ?`).all(ftsQuery, projectId, cap);
+      if (broadIds.length >= cap) truncated = true;
+    }
+    if (broadIds.length) push(fetchByIds(raw, projectId, broadIds, idFilterSql, idFilterParams));
+    const ftsCameBackEmpty = contentFtsReady && trimmed.length >= 3 && broadIds.length === 0 && byId.size === 0;
+    if (!deferPhrase && (!contentFtsReady || trimmed.length < 3 || ftsCameBackEmpty)) {
+      push(fetchByIds(raw, projectId, sqlNeedleIds(trimmed), idFilterSql, idFilterParams));
+    }
+  }
+  let matchMode = "phrase";
+  let termMatch;
+  if (byId.size === 0) {
+    const terms = contentQueryTerms(trimmed);
+    if (terms.length > 0 && hasWhitespace(trimmed)) {
+      matchMode = "terms";
+      const probedTerms = terms.slice(0, GIANT_TERM_BUDGET);
+      if (probedTerms.length < terms.length) truncated = true;
+      const scored = /* @__PURE__ */ new Map();
+      for (const term of probedTerms) {
+        for (const row of fetchByIds(raw, projectId, sqlNeedleIds(term), idFilterSql, idFilterParams)) {
+          const weight = bestFieldTermScore(row, term);
+          if (weight === 0) continue;
+          const existing = scored.get(row.id);
+          if (existing) {
+            existing.score += weight;
+            existing.hits.push(term);
+          } else {
+            scored.set(row.id, { row, score: weight, hits: [term] });
+          }
+        }
+      }
+      const ordered = [...scored.values()].sort(
+        (a, b) => b.score - a.score || b.hits.length - a.hits.length || b.row.complexity - a.row.complexity || compareCodeUnits(a.row.relativePath, b.row.relativePath)
+      );
+      for (const entry of ordered) byId.set(entry.row.id, { row: entry.row, score: entry.score });
+      if (ordered.length > 0) termMatch = { queryTerms: probedTerms, topMatched: ordered[0].hits };
+    }
+  }
+  if (deferPhrase && byId.size === 0) {
+    for (const row of fetchByIds(raw, projectId, sqlNeedleIds(trimmed), idFilterSql, idFilterParams)) {
+      const score = contentScore(row, trimmed.toLowerCase());
+      if (score > 0) byId.set(row.id, { row, score });
+    }
+  }
+  const coverage = raw.prepare(
+    "SELECT COUNT(*) AS symbols, SUM(CASE WHEN source_text IS NOT NULL THEN 1 ELSE 0 END) AS withBody FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id WHERE s.project_id = ? AND COALESCE(s.line_start, 0) > 0 AND s.name NOT LIKE '/%/%'" + idFilterSql
+  ).get(projectId, ...idFilterParams);
+  const coverageSymbols = Number(coverage?.symbols ?? 0);
+  const withBody = Number(coverage?.withBody ?? 0);
+  const bodyCoverage = { withBody, symbols: coverageSymbols, ratio: coverageSymbols ? withBody / coverageSymbols : 1 };
+  const ranked = [...byId.values()].sort((a, b) => b.score - a.score || b.row.complexity - a.row.complexity || compareCodeUnits(a.row.relativePath, b.row.relativePath)).map((entry) => entry.row);
+  const page = ranked.slice(offset, offset + maxResults);
+  return buildResults(raw, page, "content", maxResults, {
+    totalMatches: ranked.length,
+    truncated,
+    matchMode,
+    ...termMatch ? { termMatch } : {},
+    bodyCoverage
+  });
+}
+function contentScore(row, lowerNeedle) {
+  let score = 0;
+  const lowerName = row.name.toLowerCase();
+  if (lowerName === lowerNeedle) score += 3;
+  else if (lowerName.startsWith(lowerNeedle)) score += 3;
+  else if (lowerName.includes(lowerNeedle)) score += 1;
+  if ((row.qualifiedName ?? "").toLowerCase().includes(lowerNeedle)) score += 2;
+  if ((row.docstring ?? "").toLowerCase().includes(lowerNeedle)) score += 1;
+  if (row.sourceText && row.sourceText.toLowerCase().includes(lowerNeedle)) score += 1;
+  return score;
+}
+function selectJoined(raw, projectId, predicate, params) {
+  return raw.prepare(
+    "SELECT s.id, s.file_id AS fileId, s.name, s.qualified_name AS qualifiedName, s.docstring, s.source_text AS sourceText, s.symbol_type AS symbolType, COALESCE(s.line_start, 0) AS line, COALESCE(s.line_end, 0) AS lineEnd, COALESCE(s.complexity, 0) AS complexity, f.relative_path AS relativePath, f.path AS filePath, COALESCE(f.language, 'unknown') AS language FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id WHERE s.project_id = ? AND COALESCE(s.line_start, 0) > 0 AND s.name NOT LIKE '/%/%' AND " + predicate
+  ).all(projectId, ...params);
+}
+function languageClause(options) {
+  let sql = "";
+  const params = [];
+  if (options.languages?.length) {
+    sql += " AND f.language COLLATE NOCASE IN (" + options.languages.map(() => "?").join(",") + ")";
+    params.push(...options.languages);
+  }
+  if (options.symbolKind) {
+    sql += " AND s.symbol_type COLLATE NOCASE = ?";
+    params.push(options.symbolKind);
+  }
+  return { sql, params };
+}
+function fetchByIds(raw, projectId, idRows, filterSql, filterParams) {
+  const distinct = [...new Set(idRows.map((r) => r.id))];
+  if (distinct.length === 0) return [];
+  const out = [];
+  for (let start = 0; start < distinct.length; start += ID_JOIN_CHUNK) {
+    const chunk = distinct.slice(start, start + ID_JOIN_CHUNK);
+    const placeholders = chunk.map(() => "?").join(",");
+    out.push(
+      ...raw.prepare(
+        "SELECT s.id, s.file_id AS fileId, s.name, s.qualified_name AS qualifiedName, s.docstring, s.source_text AS sourceText, s.symbol_type AS symbolType, COALESCE(s.line_start, 0) AS line, COALESCE(s.line_end, 0) AS lineEnd, COALESCE(s.complexity, 0) AS complexity, f.relative_path AS relativePath, f.path AS filePath, COALESCE(f.language, 'unknown') AS language FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id WHERE s.id IN (" + placeholders + ")" + filterSql
+      ).all(...chunk, ...filterParams)
+    );
+  }
+  return out;
+}
+function buildResults(raw, page, mode, _maxResults, meta = { totalMatches: page.length }) {
+  const results = withMeta([], mode);
+  results.totalMatches = meta.totalMatches;
+  if (meta.truncated) results.truncated = true;
+  if (meta.matchMode) results.matchMode = meta.matchMode;
+  if (meta.termMatch) results.termMatch = meta.termMatch;
+  if (meta.bodyCoverage) results.bodyCoverage = meta.bodyCoverage;
+  for (const row of page) {
+    results.push({
+      file: row.relativePath,
+      fileId: row.fileId,
+      line: row.line,
+      column: 0,
+      context: row.docstring ? row.symbolType + ": " + row.name + " \u2014 " + firstLine(row.docstring) : row.symbolType + ": " + row.name,
+      symbolName: row.name,
+      symbolType: row.symbolType,
+      language: row.language,
+      matchType: "content",
+      // When the match came from the BODY and there is no docstring, the first
+      // body line is the honest snippet: it shows why this symbol matched rather
+      // than repeating its name.
+      snippet: row.docstring ? firstLine(row.docstring) : row.sourceText ? firstLine(row.sourceText) : row.qualifiedName || row.name,
+      complexity: row.complexity,
+      _relevance: 1
+    });
+  }
+  try {
+    const freshness = checkResultsFreshness(raw, results.map((result) => ({ fileId: result.fileId })));
+    let staleCount = 0;
+    for (const result of results) {
+      if (["stale", "missing"].includes(freshness.get(result.fileId) ?? "")) {
+        result.stale = true;
+        staleCount++;
+      }
+    }
+    results.staleCount = staleCount;
+    results.freshCount = results.length - staleCount;
+  } catch {
+    results.freshnessError = true;
+  }
+  return results;
+}
+function rankWithFts5(raw, query, candidates) {
+  if (candidates.length < 2) return candidates;
+  const tableName = "__bb_content_fts_" + Math.random().toString(36).slice(2, 10);
+  const table = "temp." + tableName;
+  try {
+    raw.exec("CREATE VIRTUAL TABLE " + table + " USING fts5(id UNINDEXED, name, qualified_name, docstring, source_text)");
+    const insert = raw.prepare("INSERT INTO " + table + " (id, name, qualified_name, docstring, source_text) VALUES (?, ?, ?, ?, ?)");
+    for (const row of candidates) {
+      insert.run(row.id, row.name, row.qualifiedName ?? "", row.docstring ?? "", row.sourceText ?? "");
+    }
+    const terms = splitOnWhitespace(query).filter(Boolean).map(ftsQuote).join(" OR ");
+    if (!terms) return candidates;
+    const ranked = raw.prepare(
+      "SELECT id, bm25(" + tableName + ") AS score FROM " + table + " WHERE " + tableName + " MATCH ?"
+    ).all(terms);
+    if (ranked.length === 0) return candidates;
+    const byId = new Map(candidates.map((row) => [row.id, row]));
+    const lowerNeedle = query.toLowerCase();
+    const bm25Position = /* @__PURE__ */ new Map();
+    ranked.forEach((match, index) => bm25Position.set(match.id, index));
+    const ordered = ranked.map((match) => byId.get(match.id)).filter((row) => !!row).sort(
+      (a, b) => (
+        // The documented weights beat the ranker: a name hit outranks a
+        // docstring hit outranks a body hit. bm25 orders within a class.
+        phraseFieldWeight(b, lowerNeedle) - phraseFieldWeight(a, lowerNeedle) || (bm25Position.get(a.id) ?? 0) - (bm25Position.get(b.id) ?? 0) || b.complexity - a.complexity || compareCodeUnits(a.relativePath, b.relativePath)
+      )
+    );
+    if (ordered.length < candidates.length) {
+      const placed = new Set(ordered.map((row) => row.id));
+      for (const row of sortByFieldWeight(query, candidates)) {
+        if (!placed.has(row.id)) {
+          ordered.push(row);
+          placed.add(row.id);
+        }
+      }
+    }
+    return ordered;
+  } catch {
+    return sortByFieldWeight(query, candidates);
+  } finally {
+    try {
+      raw.exec("DROP TABLE IF EXISTS " + table);
+    } catch {
+    }
+  }
+}
+var BODY_MATCH_WEIGHT = 1;
+var QUESTION_FRAME_WORDS = /* @__PURE__ */ new Set([
+  "how",
+  "where",
+  "what",
+  "which",
+  "who",
+  "when",
+  "why",
+  "does",
+  "do",
+  "did",
+  "is",
+  "are",
+  "was",
+  "were",
+  "the",
+  "a",
+  "an",
+  "of",
+  "to",
+  "in",
+  "on",
+  "at",
+  "for",
+  "with",
+  "and",
+  "or",
+  "it",
+  "its",
+  "this",
+  "that",
+  "from",
+  "by",
+  "be",
+  "been",
+  "can",
+  "could",
+  "should",
+  "would",
+  "there",
+  "their"
+]);
+var TERMS_FALLBACK_CAP = 2e3;
+function hasWhitespace(text) {
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code === 32 || code >= 9 && code <= 13 || code === 133 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288) return true;
+  }
+  return false;
+}
+function splitOnWhitespace(text) {
+  const parts = [];
+  let start = -1;
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    const space = code === 32 || code >= 9 && code <= 13 || code === 133 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288;
+    if (space) {
+      if (start !== -1) {
+        parts.push(text.slice(start, i));
+        start = -1;
+      }
+    } else if (start === -1) start = i;
+  }
+  if (start !== -1) parts.push(text.slice(start));
+  return parts;
+}
+function phraseFieldWeight(row, lowerNeedle) {
+  if (row.name.toLowerCase().includes(lowerNeedle)) return 3;
+  if ((row.qualifiedName ?? "").toLowerCase().includes(lowerNeedle)) return 2;
+  if ((row.docstring ?? "").toLowerCase().includes(lowerNeedle)) return 1;
+  if (row.sourceText && row.sourceText.toLowerCase().includes(lowerNeedle)) return 1;
+  return 0;
+}
+function bestFieldTermScore(row, lowerTerm) {
+  if (row.name.toLowerCase().includes(lowerTerm)) return 3;
+  if ((row.qualifiedName ?? "").toLowerCase().includes(lowerTerm)) return 2;
+  if ((row.docstring ?? "").toLowerCase().includes(lowerTerm)) return 1;
+  if (row.sourceText && row.sourceText.toLowerCase().includes(lowerTerm)) return 1;
+  return 0;
+}
+function contentQueryTerms(query) {
+  const terms = /* @__PURE__ */ new Set();
+  for (const t of tokenizeForEmbedding(query)) {
+    if (t.length < 2) continue;
+    if (QUESTION_FRAME_WORDS.has(t)) continue;
+    terms.add(t);
+  }
+  return [...terms];
+}
+function matchContentRows(query, corpus) {
+  let termMatch;
+  const needle = query.toLowerCase();
+  const matched = [];
+  for (const row of corpus) {
+    if (row.name.toLowerCase().includes(needle)) matched.push(row);
+    else if ((row.qualifiedName ?? "").toLowerCase().includes(needle)) matched.push(row);
+    else if ((row.docstring ?? "").toLowerCase().includes(needle)) matched.push(row);
+    else if (row.sourceText && row.sourceText.toLowerCase().includes(needle)) matched.push(row);
+  }
+  if (matched.length > 0) return { rows: matched, mode: "phrase", truncated: false };
+  const terms = contentQueryTerms(query);
+  const isSingleToken = !hasWhitespace(query.trim());
+  if (terms.length === 0 || isSingleToken) return { rows: [], mode: "phrase", truncated: false };
+  const scored = [];
+  for (const row of corpus) {
+    let score = 0;
+    const hitTerms = [];
+    for (const t of terms) {
+      const best = bestFieldTermScore(row, t);
+      if (best > 0) {
+        score += best;
+        hitTerms.push(t);
+      }
+    }
+    if (hitTerms.length > 0) scored.push({ row, score, all: hitTerms.length === terms.length ? 1 : 0, hitTerms });
+  }
+  if (scored.length === 0) return { rows: [], mode: "terms", truncated: false };
+  scored.sort(
+    (a, b) => b.score - a.score || b.all - a.all || b.row.complexity - a.row.complexity || compareCodeUnits(a.row.relativePath, b.row.relativePath)
+  );
+  const truncated = scored.length > TERMS_FALLBACK_CAP;
+  termMatch = {
+    queryTerms: terms,
+    topMatched: scored[0].hitTerms
+  };
+  return { rows: scored.slice(0, TERMS_FALLBACK_CAP).map((e) => e.row), mode: "terms", truncated, termMatch };
+}
+function sortByFieldWeight(query, corpus) {
+  const needle = query.toLowerCase();
+  const scored = [];
+  for (const row of corpus) {
+    let score = 0;
+    if (row.name.toLowerCase().includes(needle)) score += 3;
+    if ((row.qualifiedName ?? "").toLowerCase().includes(needle)) score += 2;
+    if ((row.docstring ?? "").toLowerCase().includes(needle)) score += 1;
+    if (row.sourceText && row.sourceText.toLowerCase().includes(needle)) score += BODY_MATCH_WEIGHT;
+    if (score > 0) scored.push({ row, score });
+  }
+  scored.sort((a, b) => b.score - a.score || b.row.complexity - a.row.complexity || compareCodeUnits(a.row.relativePath, b.row.relativePath));
+  return scored.map((entry) => entry.row);
+}
+function compareCodeUnits(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function withMeta(results, mode) {
+  results.searchMode = mode;
+  if (results.staleCount === void 0) results.staleCount = 0;
+  if (results.freshCount === void 0) results.freshCount = 0;
+  if (results.totalMatches === void 0) results.totalMatches = results.length;
+  return results;
+}
+export {
+  contentQueryTerms,
+  hasWhitespace,
+  rebuildContentSearchIndex,
+  searchContent,
+  splitOnWhitespace
+};

package/dist/database-76RP44JG.js

@@ -0,0 +1,9 @@
+import {
+  BrainDatabase
+} from "./chunk-QKTRECYS.js";
+import "./chunk-2BSKD7O3.js";
+import "./chunk-ROMM6KMC.js";
+import "./chunk-MLKGABMK.js";
+export {
+  BrainDatabase
+};