@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-GBI7V7KY.js

@@ -0,0 +1,69 @@
+// src/lsp/relations.ts
+var DECLARATION_RELATIONSHIPS = /* @__PURE__ */ new Set(["contains", "exports"]);
+function isDeclarationRelationship(relationshipType) {
+  return DECLARATION_RELATIONSHIPS.has(relationshipType.trim().toLowerCase());
+}
+function relationDirection(row, symbolId) {
+  const isSource = row.source_symbol_id === symbolId;
+  const isTarget = row.target_symbol_id === symbolId;
+  if (isSource && isTarget) return "self";
+  if (isTarget) return "incoming";
+  if (isSource) return "outgoing";
+  return "unrelated";
+}
+function isUsageSiteRow(row, symbolId) {
+  return relationDirection(row, symbolId) === "incoming" && !isDeclarationRelationship(row.relationship_type);
+}
+function isUsageSite(site) {
+  return site.reversed === true && !isDeclarationRelationship(site.relationshipType);
+}
+function isUsageSiteAnyKind(site) {
+  const kinds = site.relationshipTypes;
+  if (site.reversed !== true) return false;
+  if (kinds === void 0 || kinds.length === 0) return isUsageSite(site);
+  return kinds.some((k) => !isDeclarationRelationship(k));
+}
+function usageSites(sites) {
+  return sites.filter(isUsageSiteAnyKind);
+}
+var USAGE_SITE_FILTER_LABEL = "usage sites only; declaration and callees excluded";
+var USAGE_COUNT_UNIT_LABEL = "counted once per place: usage sites that resolve to the same file and line count as one, and the shared rows are reported separately";
+function countUnresolvedNameMatchesByProjectAndName(db, projectId, name) {
+  const out = { name, external: 0, unresolved: 0, total: 0 };
+  if (!name) return out;
+  try {
+    const stmt = db.prepare(
+      `SELECT target_basis AS b, COUNT(*) AS c
+         FROM brain_relationship
+        WHERE project_id = ? AND target_external = ? AND target_symbol_id IS NULL
+        GROUP BY target_basis`
+    );
+    const rows = stmt.all?.(projectId, name) ?? [];
+    for (const r of rows) {
+      const c = Number(r.c ?? 0);
+      if (r.b === "external") out.external += c;
+      else out.unresolved += c;
+      out.total += c;
+    }
+  } catch {
+  }
+  return out;
+}
+function countUnresolvedNameMatches(db, symbolId) {
+  try {
+    const sym = db.prepare("SELECT project_id AS p, name AS n FROM brain_symbol WHERE id = ?").get(symbolId);
+    if (!sym || !sym.n) return null;
+    return countUnresolvedNameMatchesByProjectAndName(db, sym.p, sym.n);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  isDeclarationRelationship,
+  isUsageSiteRow,
+  usageSites,
+  USAGE_SITE_FILTER_LABEL,
+  USAGE_COUNT_UNIT_LABEL,
+  countUnresolvedNameMatches
+};

package/dist/chunk-GEFFO6O2.js

@@ -0,0 +1,152 @@
+// src/brain/semantic/vector-binary.ts
+var HOST_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
+function vectorBlobBytes(dimension) {
+  return dimension * 4;
+}
+function encodeVectorBlob(vector) {
+  const n = vector.length;
+  const bytes = Buffer.allocUnsafe(n * 4);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  for (let i = 0; i < n; i++) view.setFloat32(i * 4, vector[i], true);
+  return bytes;
+}
+function decodeVectorBlob(value, dimension) {
+  if (!value || dimension <= 0) return null;
+  let bytes;
+  if (value instanceof Uint8Array) bytes = value;
+  else if (value instanceof ArrayBuffer) bytes = new Uint8Array(value);
+  else return null;
+  const need = vectorBlobBytes(dimension);
+  if (bytes.byteLength !== need) return null;
+  if (HOST_LITTLE_ENDIAN && bytes.byteOffset % 4 === 0) {
+    return new Float32Array(bytes.buffer, bytes.byteOffset, dimension);
+  }
+  const out = new Float32Array(dimension);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  for (let i = 0; i < dimension; i++) out[i] = view.getFloat32(i * 4, true);
+  return out;
+}
+function scanJsonVectorInto(text, out) {
+  const len = text.length;
+  let n = 0;
+  let i = 1;
+  let sign = 1;
+  let value = 0;
+  let fracDiv = 1;
+  let inFrac = false;
+  let seenDigit = false;
+  const cap = out.length;
+  while (i < len) {
+    const c = text.charCodeAt(i);
+    if (c === 45) {
+      sign = -1;
+      i++;
+      continue;
+    }
+    if (c === 43) {
+      i++;
+      continue;
+    }
+    if (c >= 48 && c <= 57) {
+      const d = c - 48;
+      if (inFrac) {
+        fracDiv *= 10;
+        value += d / fracDiv;
+      } else {
+        value = value * 10 + d;
+      }
+      seenDigit = true;
+      i++;
+      continue;
+    }
+    if (c === 46) {
+      inFrac = true;
+      i++;
+      continue;
+    }
+    if (c === 101 || c === 69) {
+      let j = i + 1;
+      let esign = 1;
+      if (text.charCodeAt(j) === 45) {
+        esign = -1;
+        j++;
+      } else if (text.charCodeAt(j) === 43) {
+        j++;
+      }
+      let ev = 0;
+      let anyDigit = false;
+      while (j < len) {
+        const d = text.charCodeAt(j);
+        if (d < 48 || d > 57) break;
+        ev = ev * 10 + (d - 48);
+        anyDigit = true;
+        j++;
+      }
+      if (!anyDigit) return 0;
+      value *= Math.pow(10, esign * ev);
+      i = j;
+      continue;
+    }
+    if (c === 44 || c === 93) {
+      if (!seenDigit) return 0;
+      if (n >= cap) return 0;
+      out[n++] = sign * value;
+      sign = 1;
+      value = 0;
+      inFrac = false;
+      fracDiv = 1;
+      seenDigit = false;
+      if (c === 93) {
+        for (let k = i + 1; k < len; k++) {
+          const w = text.charCodeAt(k);
+          if (w !== 32 && w !== 9 && w !== 10 && w !== 13) return 0;
+        }
+        return n;
+      }
+      i++;
+      continue;
+    }
+    if (c === 32 || c === 9 || c === 10 || c === 13 || c === 91) {
+      i++;
+      continue;
+    }
+    return 0;
+  }
+  return 0;
+}
+function cosineFloat32(a, b, dimension) {
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < dimension; i++) {
+    const x = a[i];
+    const y = b[i];
+    dot += x * y;
+    na += x * x;
+    nb += y * y;
+  }
+  if (na === 0 || nb === 0) return 0;
+  return dot / (Math.sqrt(na) * Math.sqrt(nb));
+}
+function l2Norm(a, dimension) {
+  let n = 0;
+  for (let i = 0; i < dimension; i++) n += a[i] * a[i];
+  return Math.sqrt(n);
+}
+function readRowVector(blob, jsonText, dimension, scratch) {
+  const fromBlob = decodeVectorBlob(blob, dimension);
+  if (fromBlob) return fromBlob;
+  if (typeof jsonText !== "string" || jsonText.length === 0) return null;
+  const n = scanJsonVectorInto(jsonText, scratch);
+  return n === dimension ? scratch : null;
+}
+
+export {
+  vectorBlobBytes,
+  encodeVectorBlob,
+  decodeVectorBlob,
+  scanJsonVectorInto,
+  cosineFloat32,
+  l2Norm,
+  readRowVector
+};

package/dist/chunk-HOWAQXJO.js

@@ -0,0 +1,236 @@
+import {
+  readSymbolSnippet
+} from "./chunk-3CTFIJJB.js";
+import {
+  checkResultsFreshness
+} from "./chunk-QLK6ED4Q.js";
+import {
+  BrainDatabase
+} from "./chunk-KLK3PBTO.js";
+import {
+  analysis_exclusions_exports
+} from "./chunk-SM7RFQRO.js";
+
+// src/intelligence/search/symbol-search.ts
+var DEFAULT_PAGE_SIZE = 100;
+function normalizePageSize(value) {
+  if (value === void 0 || value === null) return DEFAULT_PAGE_SIZE;
+  const n = Math.trunc(Number(value));
+  if (!Number.isFinite(n) || n < 0) return DEFAULT_PAGE_SIZE;
+  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;
+}
+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}'`;
+var NON_ASCII = /[^\x00-\x7F]/;
+function longestAsciiPrefix(value) {
+  let i = 0;
+  while (i < value.length && value.charCodeAt(i) < 128) i++;
+  return value.slice(0, i);
+}
+function isNoiseCandidate(row) {
+  return analysis_exclusions_exports.isHardNoisePath(row.relativePath) || analysis_exclusions_exports.isNoiseSymbolName(row.name);
+}
+async function searchSymbols(projectId, rawQuery, options = {}) {
+  const raw = await BrainDatabase.getRawInstance(projectId, { readonly: true });
+  if (options.mode === "content") {
+    const { searchContent } = await import("./content-search-642F7E5V.js");
+    return searchContent(projectId, rawQuery, options);
+  }
+  if (options.mode === "regex" || options.regex) {
+    const { searchRegex } = await import("./regex-search-OPTLKUN5.js");
+    return searchRegex(projectId, rawQuery, options);
+  }
+  const query = String(rawQuery ?? "").trim();
+  const maxResults = normalizePageSize(options.maxResults);
+  const offset = normalizeOffset(options.offset);
+  if (!query) return emptyResult("symbol");
+  const caseSensitive = options.caseSensitive === true;
+  const unicodeQuery = NON_ASCII.test(query);
+  const phases = buildPhases(query, options.exact === true, caseSensitive, unicodeQuery);
+  const budget = offset + maxResults;
+  const fetchCap = Math.min(FETCH_CAP_MAX, Math.max(MIN_FETCH_CAP, budget * 4));
+  const idCap = Math.min(ID_CAP_MAX, Math.max(MIN_ID_CAP, budget * 4));
+  const candidates = [];
+  const seen = /* @__PURE__ */ new Set();
+  const truncationReasons = /* @__PURE__ */ new Set();
+  for (const phase of phases) {
+    const rows = await runPhase(raw, projectId, phase, { fetchCap, idCap, options, query, caseSensitive });
+    if (rows.truncated) truncationReasons.add(`candidate-cap:${phase.relevance}`);
+    for (const row of rows.rows) {
+      if (seen.has(row.id)) continue;
+      seen.add(row.id);
+      candidates.push({ ...row, phaseRelevance: phase.relevance });
+    }
+  }
+  const beforeNoise = candidates.length;
+  const kept = candidates.filter((row) => !isNoiseCandidate(row));
+  if (beforeNoise !== kept.length) truncationReasons.add("noise-filter");
+  const folded = unicodeQuery ? query.toLowerCase() : query;
+  const score = (name) => name.toLowerCase() === folded ? 3 : name.toLowerCase().startsWith(folded) ? 2 : 1;
+  kept.sort((a, b) => {
+    return score(b.name) - score(a.name) || (analysis_exclusions_exports.isTestPath(a.relativePath) ? 1 : 0) - (analysis_exclusions_exports.isTestPath(b.relativePath) ? 1 : 0) || b.complexity - a.complexity || compareCodeUnits(a.relativePath, b.relativePath) || compareCodeUnits(a.name, b.name);
+  });
+  const page = kept.slice(offset, offset + maxResults);
+  const results = emptyResult("symbol");
+  for (const row of page) {
+    results.push({
+      file: row.relativePath,
+      fileId: row.fileId,
+      line: row.line,
+      column: 0,
+      context: `${row.symbolType}: ${row.name}`,
+      symbolName: row.name,
+      symbolType: row.symbolType,
+      language: row.language,
+      matchType: "symbol",
+      snippet: options.includeContent ? await readSymbolSnippet(row.filePath, row.line, row.lineEnd) || row.name : row.name,
+      complexity: row.complexity,
+      _relevance: score(row.name)
+    });
+  }
+  results.totalMatches = kept.length;
+  results.truncated = truncationReasons.size > 0;
+  if (truncationReasons.size > 0) results.truncationReason = [...truncationReasons].sort().join(",");
+  applyFreshness(raw, results);
+  return results;
+}
+function emptyResult(mode) {
+  const results = [];
+  results.searchMode = mode;
+  results.staleCount = 0;
+  results.freshCount = 0;
+  results.totalMatches = 0;
+  return results;
+}
+function compareCodeUnits(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function buildPhases(query, exact, caseSensitive, unicodeQuery) {
+  if (unicodeQuery) {
+    const asciiPrefix = longestAsciiPrefix(query);
+    const narrow = asciiPrefix.length >= 2;
+    if (exact) {
+      return narrow ? [{ clause: "s.name LIKE ? ESCAPE '\\'", relevance: 3, value: escapeLike(asciiPrefix) + "%", substring: false, fold: "equal" }] : [{ clause: "LENGTH(s.name) = LENGTH(?)", relevance: 3, value: query, substring: false, fold: "equal" }];
+    }
+    if (narrow) {
+      return [
+        { clause: "s.name LIKE ? ESCAPE '\\'", relevance: 3, value: escapeLike(asciiPrefix) + "%", substring: false, fold: "equal" },
+        { clause: "s.name LIKE ? ESCAPE '\\'", relevance: 2, value: escapeLike(asciiPrefix) + "%", substring: false, fold: "prefix" },
+        { clause: "1 = 1", relevance: 1, value: "", substring: true, fold: "substring" }
+      ];
+    }
+    return [
+      { clause: "LENGTH(s.name) = LENGTH(?)", relevance: 3, value: query, substring: true, fold: "equal" },
+      { clause: "LENGTH(s.name) >= LENGTH(?)", relevance: 2, value: query, substring: true, fold: "prefix" },
+      { clause: "LENGTH(s.name) >= LENGTH(?)", relevance: 1, value: query, substring: true, fold: "substring" }
+    ];
+  }
+  if (exact) {
+    return [{ clause: caseSensitive ? "s.name = ?" : "s.name = ? COLLATE NOCASE", relevance: 3, value: query, substring: false }];
+  }
+  if (caseSensitive) {
+    return [
+      { clause: "s.name = ?", relevance: 3, value: query, substring: false },
+      // Indexed range scan, not instr(): `instr(name, ?)` is a full table scan
+      // for every query (EXPLAIN QUERY PLAN: `SCAN brain_symbol`).
+      { clause: "s.name LIKE ? ESCAPE '\\'", relevance: 2, value: escapeLike(query) + "%", substring: false },
+      { clause: "s.name LIKE ? ESCAPE '\\'", relevance: 1, value: "%" + escapeLike(query) + "%", substring: true }
+    ];
+  }
+  return [
+    { clause: "s.name = ? COLLATE NOCASE", relevance: 3, value: query, substring: false },
+    { clause: "s.name LIKE ? COLLATE NOCASE ESCAPE '\\'", relevance: 2, value: escapeLike(query) + "%", substring: false },
+    { clause: "s.name LIKE ? COLLATE NOCASE ESCAPE '\\'", relevance: 1, value: "%" + escapeLike(query) + "%", substring: true }
+  ];
+}
+function symbolSearchPhases(query, exact, caseSensitive) {
+  return buildPhases(query, exact, caseSensitive, NON_ASCII.test(query));
+}
+var MIN_FETCH_CAP = 2e4;
+var FETCH_CAP_MAX = 2e5;
+var MIN_ID_CAP = 2e4;
+var ID_CAP_MAX = 2e5;
+var ID_JOIN_CHUNK = 500;
+async function runPhase(raw, projectId, phase, ctx) {
+  const { filters, params } = filterSql(ctx.options);
+  const base = `${SELECT_COLUMNS} 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}`;
+  if (phase.fold) {
+    const rows2 = raw.prepare(`${base} AND ${phase.clause} LIMIT ?`).all(projectId, ...params, phase.value, ctx.fetchCap);
+    return { rows: filterFolded(rows2, phase, ctx.query), truncated: rows2.length >= ctx.fetchCap };
+  }
+  if (!phase.substring) {
+    const rows2 = raw.prepare(`${base} AND ${phase.clause} LIMIT ?`).all(projectId, ...params, phase.value, ctx.fetchCap);
+    return { rows: rows2, truncated: rows2.length >= ctx.fetchCap };
+  }
+  const { filters: idFilters, params: idFilterParams } = filterSql(ctx.options, "s", "f");
+  const idRows = raw.prepare(
+    `SELECT s.id 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 '/%/%'${idFilters} AND ${phase.clause} LIMIT ?`
+  ).all(projectId, ...idFilterParams, phase.value, ctx.idCap);
+  if (idRows.length === 0) return { rows: [], truncated: false };
+  const distinct = [...new Set(idRows.map((row) => row.id))];
+  const rows = [];
+  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(",");
+    const page = raw.prepare(`${SELECT_COLUMNS} FROM brain_symbol s JOIN brain_file f ON f.id = s.file_id WHERE s.id IN (${placeholders})${filters}`).all(...chunk, ...params);
+    rows.push(...page);
+  }
+  return { rows, truncated: idRows.length >= ctx.idCap };
+}
+var SELECT_COLUMNS = `SELECT s.id, s.file_id AS fileId, s.name, 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`;
+function filterSql(options, symbolAlias = "s", fileAlias = "f") {
+  let filters = "";
+  const params = [];
+  if (options.languages?.length) {
+    filters += ` AND ${fileAlias}.language COLLATE NOCASE IN (${options.languages.map(() => "?").join(",")})`;
+    params.push(...options.languages);
+  }
+  if (options.symbolKind) {
+    filters += ` AND ${symbolAlias}.symbol_type COLLATE NOCASE = ?`;
+    params.push(options.symbolKind);
+  }
+  return { filters, params };
+}
+function filterFolded(rows, phase, query) {
+  const needle = query.toLowerCase();
+  return rows.filter((row) => {
+    const name = row.name.toLowerCase();
+    if (phase.fold === "equal") return name === needle;
+    if (phase.fold === "prefix") return name.startsWith(needle);
+    return name.includes(needle);
+  });
+}
+function applyFreshness(raw, results) {
+  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;
+  }
+}
+
+export {
+  searchSymbols,
+  symbolSearchPhases
+};