@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-QLK6ED4Q.js

@@ -0,0 +1,235 @@
+// src/brain/freshness.ts
+import { createHash } from "crypto";
+import { readFileSync, existsSync, statSync } from "fs";
+function hashFileContent(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function fileUnchangedSince(path, indexedHash, indexedSize, indexedMtime) {
+  try {
+    const stat = statSync(path);
+    if (indexedSize !== null && indexedSize !== void 0 && indexedMtime !== null && indexedMtime !== void 0 && stat.size === indexedSize && Math.floor(stat.mtimeMs) === Math.floor(indexedMtime)) return true;
+    const content = readFileSync(path);
+    return hashFileContent(content) === indexedHash;
+  } catch {
+    return false;
+  }
+}
+function checkFileFreshness(raw, fileId) {
+  try {
+    const row = raw.prepare("SELECT path, file_hash, size_bytes, last_modified FROM brain_file WHERE id = ?").get(fileId);
+    if (!row) return null;
+    if (!existsSync(row.path)) return { fileId, path: row.path, indexedHash: row.file_hash, status: "missing" };
+    const fresh = fileUnchangedSince(row.path, row.file_hash, row.size_bytes, row.last_modified);
+    return { fileId, path: row.path, indexedHash: row.file_hash, status: fresh ? "fresh" : "stale" };
+  } catch {
+    return null;
+  }
+}
+function checkResultsFreshness(raw, rows) {
+  const result = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  for (const r of rows) {
+    if (!r.fileId || seen.has(r.fileId)) continue;
+    seen.add(r.fileId);
+    const f = checkFileFreshness(raw, r.fileId);
+    if (f) result.set(r.fileId, f.status);
+  }
+  return result;
+}
+function checkSymbolFreshness(raw, symbolId) {
+  try {
+    const row = raw.prepare("SELECT file_id FROM brain_symbol WHERE id = ?").get(symbolId);
+    if (!row) return null;
+    return checkFileFreshness(raw, row.file_id);
+  } catch {
+    return null;
+  }
+}
+function stableFileHash(id) {
+  let h = 2166136261;
+  for (let i = 0; i < id.length; i++) {
+    h ^= id.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  h ^= h >>> 16;
+  h = Math.imul(h, 2246822507);
+  h ^= h >>> 13;
+  h = Math.imul(h, 3266489909);
+  h ^= h >>> 16;
+  return h >>> 0;
+}
+function selectSampleFiles(rows, limit) {
+  const k = Math.min(limit, rows.length);
+  if (k <= 0) return [];
+  if (k >= rows.length) {
+    return [...rows].sort((a, b) => cmpPath(a.relative_path, b.relative_path) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+  }
+  const kept = [];
+  const precedes = (ah, aid, ai, bh, bid, bi) => ah < bh || ah === bh && (aid < bid || aid === bid && ai < bi);
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i];
+    const h = stableFileHash(r.id);
+    if (kept.length === k) {
+      const worst = kept[k - 1];
+      if (!precedes(h, r.id, i, worst.h, worst.r.id, worst.i)) continue;
+    }
+    let lo = 0, hi = kept.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (precedes(kept[mid].h, kept[mid].r.id, kept[mid].i, h, r.id, i)) lo = mid + 1;
+      else hi = mid;
+    }
+    kept.splice(lo, 0, { r, h, i });
+    if (kept.length > k) kept.pop();
+  }
+  return kept.map((x) => x.r).sort((a, b) => cmpPath(a.relative_path, b.relative_path) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+function cmpPath(a, b) {
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+var freshnessStats = { statCalls: 0, hashReads: 0 };
+function rawStat(p) {
+  freshnessStats.statCalls++;
+  try {
+    const s = statSync(p);
+    return { exists: true, size: s.size, mtime: Math.floor(s.mtimeMs) };
+  } catch {
+    return { exists: false, size: null, mtime: null };
+  }
+}
+function chunk(arr, n) {
+  const out = [];
+  for (let i = 0; i < arr.length; i += n) out.push(arr.slice(i, i + n));
+  return out;
+}
+function batchLoadRows(raw, ids, paths) {
+  const rows = /* @__PURE__ */ new Map();
+  const COLS = "id, path, file_hash, size_bytes, last_modified";
+  for (const c of chunk(ids, 500)) {
+    const rs = raw.prepare(`SELECT ${COLS} FROM brain_file WHERE id IN (${c.map(() => "?").join(",")})`).all(...c);
+    for (const r of rs) rows.set(r.id, r);
+  }
+  for (const c of chunk(paths, 500)) {
+    const rs = raw.prepare(`SELECT ${COLS} FROM brain_file WHERE path IN (${c.map(() => "?").join(",")})`).all(...c);
+    for (const r of rs) if (!rows.has(r.id)) rows.set(r.id, r);
+  }
+  return rows;
+}
+function classifyRow(row, statFor) {
+  const stat = statFor(row.path);
+  if (!stat.exists) return { status: "missing", reason: "file-gone" };
+  if (row.size_bytes !== null && row.size_bytes !== void 0 && row.last_modified !== null && row.last_modified !== void 0 && stat.size === row.size_bytes && stat.mtime === Math.floor(row.last_modified)) {
+    return { status: "fresh", reason: "metadata-fast-path" };
+  }
+  freshnessStats.hashReads++;
+  try {
+    const content = readFileSync(row.path);
+    return hashFileContent(content) === row.file_hash ? { status: "fresh", reason: "hash-match" } : { status: "stale", reason: "hash-differs" };
+  } catch {
+    return { status: "missing", reason: "unreadable" };
+  }
+}
+function resolveRowsFreshnessDetailed(raw, projectId, rows, opts = {}) {
+  void projectId;
+  freshnessStats.statCalls = 0;
+  freshnessStats.hashReads = 0;
+  const statCache = /* @__PURE__ */ new Map();
+  function memoStat(p) {
+    const hit = statCache.get(p);
+    if (hit) return hit;
+    const s = rawStat(p);
+    statCache.set(p, s);
+    return s;
+  }
+  function statFor(p) {
+    return memoStat(p);
+  }
+  const uniqueIds = /* @__PURE__ */ new Set();
+  const uniquePaths = /* @__PURE__ */ new Set();
+  for (const r of rows) {
+    if (r.fileId) uniqueIds.add(r.fileId);
+    else if (r.filePath) uniquePaths.add(r.filePath);
+  }
+  const byId = batchLoadRows(raw, [...uniqueIds], [...uniquePaths]);
+  const statuses = /* @__PURE__ */ new Map();
+  const reasons = /* @__PURE__ */ new Map();
+  for (const id of uniqueIds) {
+    const row = byId.get(id);
+    if (!row) {
+      statuses.set(id, "missing");
+      reasons.set(id, "no-row");
+      continue;
+    }
+    const c = classifyRow(row, statFor);
+    statuses.set(id, c.status);
+    reasons.set(id, c.reason);
+  }
+  const byPath = /* @__PURE__ */ new Map();
+  for (const r of byId.values()) if (!byPath.has(r.path)) byPath.set(r.path, r);
+  for (const p of uniquePaths) {
+    const row = byPath.get(p);
+    if (!row) {
+      statuses.set(p, "missing");
+      reasons.set(p, "no-row");
+      continue;
+    }
+    const c = classifyRow(row, statFor);
+    statuses.set(p, c.status);
+    reasons.set(p, c.reason);
+  }
+  let fresh = 0, stale = 0, missing = 0;
+  for (const s of statuses.values()) {
+    if (s === "fresh") fresh++;
+    else if (s === "stale") stale++;
+    else missing++;
+  }
+  const checked = fresh + stale + missing;
+  const summary = {
+    fresh,
+    stale,
+    missing,
+    staleRatio: checked === 0 ? 0 : (stale + missing) / checked,
+    freshnessMode: opts.freshnessMode ?? "complete"
+  };
+  return { statuses, reasons, summary };
+}
+var FRESHNESS_REMEDIATION = {
+  // M43.A1/A2: read tools now AUTO-refresh stale files within budget before
+  // answering and declare it; the strings name that automatic behavior and
+  // keep the manual interface for opt-out/over-budget cases. Substring
+  // contract (asserted by the M35 envelope gate): dir names "bb index
+  // --changed" and "bb_index"; file matches /bb index "/ and names bb_index.
+  dir: "reads auto-refresh stale files within budget when enabled \u2014 disable with BB_NO_AUTO_REFRESH=1 or refresh=false; manual repair: run: bb index --changed (or the bb_index tool with the project path \u2014 incremental, changed files only)",
+  file: 'reads auto-refresh this file within budget when enabled \u2014 disable with BB_NO_AUTO_REFRESH=1 or refresh=false; manual repair: run: bb index "<file>" (or the bb_index tool with that file path)'
+};
+var FRESHNESS_REMEDIATION_MANUAL_ONLY = {
+  dir: "this read does NOT auto-refresh \u2014 the rows describe the index as it stands; manual repair: run: bb index --changed (or the bb_index tool with the project path \u2014 incremental, changed files only)",
+  file: 'this read does NOT auto-refresh this file \u2014 the rows describe the index as it stands; manual repair: run: bb index "<file>" (or the bb_index tool with that file path)'
+};
+function buildStalenessEnvelope(summary, scope) {
+  const staleish = summary.stale + summary.missing;
+  const registered = scope.autoRefresh === false ? FRESHNESS_REMEDIATION_MANUAL_ONLY : FRESHNESS_REMEDIATION;
+  const remediation = staleish === 0 ? "" : scope.kind === "file" ? `${staleish} stale in this file \u2014 ${registered.file.replace("<file>", scope.path ?? "this file")}` : `${staleish} stale/missing \u2014 ${registered.dir}`;
+  return {
+    fresh: summary.fresh,
+    stale: summary.stale,
+    missing: summary.missing,
+    staleRatio: summary.staleRatio,
+    mode: summary.freshnessMode === "sampled" ? "sampled" : "complete",
+    remediation
+  };
+}
+
+export {
+  hashFileContent,
+  fileUnchangedSince,
+  checkFileFreshness,
+  checkResultsFreshness,
+  checkSymbolFreshness,
+  selectSampleFiles,
+  resolveRowsFreshnessDetailed,
+  FRESHNESS_REMEDIATION,
+  FRESHNESS_REMEDIATION_MANUAL_ONLY,
+  buildStalenessEnvelope
+};

package/dist/chunk-R2GW4F6R.js

@@ -0,0 +1,19 @@
+// src/ast/node-walk.ts
+function treeContainsNodeType(root, type) {
+  if (!root) return false;
+  const stack = [root];
+  while (stack.length > 0) {
+    const n = stack.pop();
+    if (!n) continue;
+    if (n.type === type) return true;
+    for (let i = 0; i < n.namedChildCount; i++) {
+      const c = n.namedChild(i);
+      if (c) stack.push(c);
+    }
+  }
+  return false;
+}
+
+export {
+  treeContainsNodeType
+};

package/dist/chunk-RCMTFSEF.js

@@ -0,0 +1,87 @@
+// src/lsp/evidence_tier.ts
+var EVIDENCE_TIERS = [
+  "structural",
+  "import_based",
+  "usage_contextual",
+  "reference_qualified",
+  "inferred"
+];
+var TIER_RANK = {
+  structural: 0,
+  import_based: 1,
+  usage_contextual: 2,
+  reference_qualified: 3,
+  inferred: 4,
+  unknown: 5
+};
+var STRUCTURAL_KINDS = /* @__PURE__ */ new Set([
+  "call",
+  "calls",
+  "extends",
+  "inherits",
+  "implements",
+  "overrides",
+  "override",
+  "contains",
+  "exports",
+  "instantiates",
+  // EXTENDED 2026-10-18 (canonical vocabulary). These three are PARSER-DETERMINISTIC by the same
+  // argument the set already carries for extends/implements: `mixes_in` reads the `with` clause,
+  // `renders` reads a JSX element's tag, `decorates` reads a decorator node attached to a
+  // declaration. Leaving them out is not neutral — every tier reader falls through to `inferred`,
+  // so an edge the analyzer read straight off the grammar would be presented as a guess.
+  "mixes_in",
+  "renders",
+  "decorates"
+]);
+var STRUCTURAL_FLOOR = 0.7;
+var IMPORT_KINDS = /* @__PURE__ */ new Set(["import", "imports", "part_of"]);
+var USAGE_CONTEXT_KINDS = /* @__PURE__ */ new Set(["reference", "references", "use", "uses", "usage"]);
+var REFERENCE_QUALIFIED_KINDS = /* @__PURE__ */ new Set(["references_qualified", "reference_qualified"]);
+function isDeclaredTier(value) {
+  return EVIDENCE_TIERS.includes(value);
+}
+function classifyTier(row) {
+  const stored = row.evidenceClass;
+  if (stored !== null && isDeclaredTier(stored)) return stored;
+  const t = row.relationshipType.trim().toLowerCase();
+  if (STRUCTURAL_KINDS.has(t)) return (row.confidence ?? 0) >= STRUCTURAL_FLOOR ? "structural" : "inferred";
+  if (IMPORT_KINDS.has(t)) return "import_based";
+  if (USAGE_CONTEXT_KINDS.has(t)) return "usage_contextual";
+  if (REFERENCE_QUALIFIED_KINDS.has(t)) return "reference_qualified";
+  return "inferred";
+}
+function evidenceClassOf(metadata) {
+  if (!metadata) return null;
+  try {
+    const parsed = JSON.parse(metadata);
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const cls = parsed.evidenceClass;
+    return typeof cls === "string" ? cls : null;
+  } catch {
+    return null;
+  }
+}
+function classifyStoredRow(row) {
+  return classifyTier({
+    relationshipType: row.relationship_type,
+    confidence: row.confidence,
+    evidenceClass: evidenceClassOf(row.metadata)
+  });
+}
+function orderTiers(tiers) {
+  const set = /* @__PURE__ */ new Set();
+  for (const t of tiers) set.add(t);
+  return [...set].sort((a, b) => TIER_RANK[a] - TIER_RANK[b]);
+}
+function primaryTier(tiers) {
+  if (tiers.length === 0) return "unknown";
+  return orderTiers(tiers)[0];
+}
+
+export {
+  classifyTier,
+  classifyStoredRow,
+  orderTiers,
+  primaryTier
+};