@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/chunk-7MBYT777.js

@@ -0,0 +1,174 @@
+import {
+  ParallelIndexerConfig,
+  parallelIndexerCliSkipPatterns
+} from "./chunk-ZETTGPAW.js";
+
+// src/ast/fingerprint.ts
+import { createHash } from "crypto";
+import { readFile, readdir, stat, open } from "fs/promises";
+import path from "path";
+function relativePathFingerprint(sortedRel) {
+  return createHash("sha1").update(Array.from(new Set(sortedRel)).sort().join("\n")).digest("hex").substring(0, 40);
+}
+async function gitIdentity(root) {
+  try {
+    const { execFile } = await import("child_process");
+    const run = (args) => new Promise((resolve) => {
+      execFile("git", ["-C", root, ...args], { timeout: 4e3 }, (err, stdout) => {
+        resolve(err ? "" : stdout.toString().trim());
+      });
+    });
+    const remote = await run(["remote", "get-url", "origin"]);
+    const head = await run(["rev-parse", "HEAD"]);
+    if (!remote && !head) return null;
+    return `${remote || "(no-remote)"}|${head || "(no-head)"}`;
+  } catch {
+    return null;
+  }
+}
+var FULL_AST_LIMIT = 1 * 1024 * 1024;
+var STRUCTURAL_LIMIT = 5 * 1024 * 1024;
+var skipDirNames = /* @__PURE__ */ new Set([".git", ".svn", ".hg", ".cache", ".nyc_output", ".venv", ".next", ".nuxt", ".svelte-kit", ".turbo"]);
+var compiledDirTokens = ["/perf/", "/Microbenchmarks/", "/wwwroot/", "/coverage/", "/node_modules/", "/dist/", "/build/", "/.git/", "/obj/", "/bin/", "/testData/"];
+var cliSkipPatterns = Array.from(
+  /* @__PURE__ */ new Set([...ParallelIndexerConfig.skipPatterns, ...parallelIndexerCliSkipPatterns()])
+);
+async function loadIgnores(root, ownPath, parentIg) {
+  try {
+    const ignore = (await import("ignore")).default;
+    const ig = ignore({ ignorecase: false }).add(parentIg);
+    const entries = await readdir(ownPath, { withFileTypes: true });
+    for (const name of [".gitignore", ".bbignore"]) {
+      const f = entries.find((e) => e.isFile() && e.name === name);
+      if (!f) continue;
+      try {
+        const content = await readFile(path.join(ownPath, f.name), "utf8");
+        ig.add(content);
+      } catch {
+      }
+    }
+    return ig;
+  } catch {
+    return parentIg;
+  }
+}
+var DEFAULT_IGNORE_PATTERNS = [
+  "**/perf/**",
+  "**/Microbenchmarks/**",
+  "**/wwwroot/**",
+  "**/testassets/**",
+  "**/benchmarkapps/**",
+  "**/coverage/**",
+  "**/testData/**"
+];
+async function readShebang(p) {
+  try {
+    const fh = await open(p, "r");
+    try {
+      const buf = Buffer.alloc(256);
+      const { bytesRead } = await fh.read(buf, 0, 256, 0);
+      return buf.subarray(0, bytesRead).toString("utf8");
+    } finally {
+      await fh.close();
+    }
+  } catch {
+    return "";
+  }
+}
+async function walk(root, dir, ig, depth, rel) {
+  if (depth > 50) return;
+  let entries = [];
+  try {
+    entries = await readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  if (dir !== root && entries.some((e) => e.isDirectory() && e.name === ".git")) return;
+  const localIg = await loadIgnores(root, dir, ig);
+  const { detectLanguageFromPath } = await import("./language-detection-DFCAU5DZ.js");
+  const jobs = [];
+  for (const entry of entries) {
+    if (entry.isDirectory() && skipDirNames.has(entry.name)) continue;
+    const fullPath = path.join(dir, entry.name);
+    const relativePath = path.relative(root, fullPath);
+    const withSlash = relativePath + (entry.isDirectory() ? "/" : "");
+    const normPath = "/" + relativePath + (entry.isDirectory() ? "/" : "");
+    if (compiledDirTokens.some((t) => normPath.includes(t))) continue;
+    if (localIg.ignores(withSlash)) continue;
+    if (entry.isDirectory()) {
+      jobs.push(walk(root, fullPath, localIg, depth + 1, rel));
+      continue;
+    }
+    if (!entry.isFile()) continue;
+    const baseName = entry.name;
+    const hasExt = baseName.lastIndexOf(".") > 0;
+    let detected = null;
+    if (hasExt) {
+      detected = detectLanguageFromPath(fullPath);
+    } else {
+      detected = detectLanguageFromPath(fullPath);
+      if (!detected) detected = detectLanguageFromPath(fullPath, await readShebang(fullPath));
+    }
+    if (!detected) continue;
+    if (cliSkipPatterns.some((p) => p.test(normPath))) continue;
+    jobs.push(
+      (async () => {
+        try {
+          const s = await stat(fullPath);
+          if (s.size > STRUCTURAL_LIMIT) return;
+          rel.push(relativePath);
+        } catch {
+        }
+      })()
+    );
+  }
+  await Promise.all(jobs);
+}
+async function computeCheckoutFingerprint(root) {
+  const { default: ignore } = await import("ignore");
+  const ig = ignore({ ignorecase: false }).add(DEFAULT_IGNORE_PATTERNS);
+  const rel = [];
+  await walk(root, root, ig, 0, rel);
+  const sorted = Array.from(new Set(rel)).sort();
+  const git = await gitIdentity(root);
+  const fingerprint = createHash("sha1").update(sorted.join("\n")).update(git ?? "").digest("hex").substring(0, 40);
+  return { fingerprint, fileCount: sorted.length, git };
+}
+function computeDbFingerprint(raw, git) {
+  const rows = raw.prepare("SELECT relative_path FROM brain_file").all();
+  const sorted = rows.map((r) => String(r.relative_path)).sort();
+  return createHash("sha1").update(sorted.join("\n")).update(git ?? "").digest("hex").substring(0, 40);
+}
+function readStoredFingerprint(raw, projectId) {
+  try {
+    const row = raw.prepare(
+      "SELECT codebase_fingerprint FROM brain_index_status WHERE project_id = ?"
+    ).get(projectId);
+    return row?.codebase_fingerprint ?? void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function persistProjectFingerprint(projectId, projectPath) {
+  try {
+    const cf = await computeCheckoutFingerprint(projectPath);
+    const { BrainDatabase } = await import("./database-76RP44JG.js");
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    raw.prepare(
+      `UPDATE brain_index_status SET codebase_fingerprint = ?, codebase_git = ?, time_updated = strftime('%s','now')*1000
+         WHERE project_id = ?`
+    ).run(cf.fingerprint, cf.git ?? null, projectId);
+    return cf.fingerprint;
+  } catch {
+    return "";
+  }
+}
+
+export {
+  relativePathFingerprint,
+  gitIdentity,
+  computeCheckoutFingerprint,
+  computeDbFingerprint,
+  readStoredFingerprint,
+  persistProjectFingerprint
+};

package/dist/chunk-AHDWGM7Q.js

@@ -0,0 +1,236 @@
+import {
+  readSymbolSnippet
+} from "./chunk-3CTFIJJB.js";
+import {
+  checkResultsFreshness
+} from "./chunk-QLK6ED4Q.js";
+import {
+  BrainDatabase
+} from "./chunk-QKTRECYS.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-7XIP555Q.js");
+    return searchContent(projectId, rawQuery, options);
+  }
+  if (options.mode === "regex" || options.regex) {
+    const { searchRegex } = await import("./regex-search-NJKHMZNO.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
+};