@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-VL52PL2T.js

@@ -0,0 +1,71 @@
+// src/lsp/identity.ts
+var IDENTITY_TRAVERSABLE_TYPES = [
+  "function",
+  "method",
+  "class",
+  "interface",
+  "trait",
+  "struct",
+  "enum",
+  "macro"
+];
+function memberFileMatches(hint, stored) {
+  const h = hint.replace(/\\/g, "/");
+  const s = stored.replace(/\\/g, "/");
+  if (h === s) return true;
+  return h.endsWith("/" + s);
+}
+function resolveMemberIdentity(db, projectId, symbolName, fileHint) {
+  try {
+    const TRAVERSABLE = IDENTITY_TRAVERSABLE_TYPES;
+    const memberRows = db.prepare(
+      `SELECT s.id, s.name, s.symbol_type AS symbolType, s.owner_symbol_id AS ownerId,
+                COALESCE(f.relative_path, f.path, '') AS file
+         FROM brain_symbol s LEFT JOIN brain_file f ON f.id = s.file_id
+         WHERE s.project_id = ? AND s.name = ?`
+    ).all(projectId, symbolName);
+    let member = memberRows[0];
+    if (memberRows.length > 1) {
+      if (!fileHint) return null;
+      const narrowed = memberRows.filter((r) => memberFileMatches(fileHint, r.file));
+      if (narrowed.length !== 1) return null;
+      member = narrowed[0];
+    }
+    if (!member) return null;
+    if (TRAVERSABLE.includes(member.symbolType)) return null;
+    const inbound = db.prepare(
+      `SELECT COUNT(*) AS c FROM brain_relationship
+         WHERE project_id = ? AND target_symbol_id = ?
+           AND relationship_type IN ('calls','instantiates','extends','implements')`
+    ).get(projectId, member.id);
+    if (typeof inbound?.c === "number" && inbound.c > 0) return null;
+    if (!member.ownerId) return null;
+    const ownerRows = db.prepare(
+      `SELECT s.id, s.name, s.symbol_type AS symbolType,
+                COALESCE(f.relative_path, f.path, '') AS file
+         FROM brain_symbol s LEFT JOIN brain_file f ON f.id = s.file_id
+         WHERE s.project_id = ? AND s.id = ?`
+    ).all(projectId, member.ownerId);
+    if (ownerRows.length !== 1) return null;
+    const owner = ownerRows[0];
+    if (!TRAVERSABLE.includes(owner.symbolType)) return null;
+    return { id: owner.id, name: owner.name, file: owner.file };
+  } catch {
+    return null;
+  }
+}
+function memberResolutionRecord(requestedName, ownerName, fileHint) {
+  return {
+    through: "owning-declaration",
+    memberName: requestedName,
+    ownerName,
+    ...fileHint ? { memberFile: fileHint } : {}
+  };
+}
+
+export {
+  IDENTITY_TRAVERSABLE_TYPES,
+  memberFileMatches,
+  resolveMemberIdentity,
+  memberResolutionRecord
+};

package/dist/chunk-VURYFIHW.js

@@ -0,0 +1,201 @@
+import {
+  BrainDatabase
+} from "./chunk-KLK3PBTO.js";
+import {
+  bbDataDir
+} from "./chunk-2BSKD7O3.js";
+
+// src/ast/index-status.ts
+import {
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  existsSync,
+  rmSync,
+  renameSync,
+  openSync,
+  fsyncSync,
+  closeSync
+} from "fs";
+import path from "path";
+var INDEX_STATUS_SCHEMA_VERSION = 2;
+var INDEX_RUN_PHASES = ["indexing", "post-processing", "complete", "failed", "cancelled"];
+var RESUMABLE_PHASES = ["indexing", "cancelled"];
+var TERMINAL_PHASES = ["complete", "failed", "cancelled"];
+function statusPath(projectId) {
+  return path.join(bbDataDir(), "status", `${projectId}.json`);
+}
+function statusTempPath(projectId) {
+  return `${statusPath(projectId)}.tmp`;
+}
+function writeStatusAtomically(projectId, contents) {
+  const target = statusPath(projectId);
+  const tmp = statusTempPath(projectId);
+  mkdirSync(path.dirname(target), { recursive: true });
+  writeFileSync(tmp, contents);
+  if (process.env.BB_STATUS_FSYNC === "1") {
+    try {
+      const fd = openSync(tmp, "r");
+      try {
+        fsyncSync(fd);
+      } finally {
+        closeSync(fd);
+      }
+    } catch {
+    }
+  }
+  renameSync(tmp, target);
+}
+function writeLiveStatus(projectId, live) {
+  try {
+    writeStatusAtomically(projectId, JSON.stringify({ ...live, schemaVersion: INDEX_STATUS_SCHEMA_VERSION, updatedAt: Date.now() }));
+  } catch {
+  }
+}
+function readIndexCheckpoint(projectId) {
+  const file = statusPath(projectId);
+  let raw;
+  try {
+    if (!existsSync(file)) {
+      return { integrity: "missing", file, problem: "no status file: this project has no recorded index run" };
+    }
+    raw = readFileSync(file, "utf8");
+  } catch (e) {
+    return { integrity: "corrupt", file, problem: `status file could not be read: ${e?.message ?? e}` };
+  }
+  if (raw.trim() === "") {
+    return { integrity: "corrupt", file, problem: "status file is empty \u2014 a run was interrupted while writing it" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    return { integrity: "corrupt", file, problem: `status file is not valid JSON (${e?.message ?? e}) \u2014 a run was interrupted while writing it` };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { integrity: "corrupt", file, problem: "status file is not a status document" };
+  }
+  const version = typeof parsed.schemaVersion === "number" ? parsed.schemaVersion : 1;
+  if (version > INDEX_STATUS_SCHEMA_VERSION) {
+    return {
+      integrity: "future-schema",
+      file,
+      problem: `status file schema v${version} is newer than this bb understands (v${INDEX_STATUS_SCHEMA_VERSION}); not interpreted`
+    };
+  }
+  if (typeof parsed.phase !== "string" || typeof parsed.updatedAt !== "number") {
+    return { integrity: "incomplete", file, problem: "status file has no phase/update timestamp" };
+  }
+  const status = {
+    ...parsed,
+    schemaVersion: version,
+    phase: parsed.phase,
+    projectId: typeof parsed.projectId === "string" ? parsed.projectId : projectId,
+    processedFiles: typeof parsed.processedFiles === "number" ? parsed.processedFiles : 0,
+    totalFiles: typeof parsed.totalFiles === "number" ? parsed.totalFiles : 0,
+    startedAt: typeof parsed.startedAt === "number" ? parsed.startedAt : parsed.updatedAt,
+    updatedAt: parsed.updatedAt
+  };
+  return { integrity: "ok", status, file };
+}
+function readLiveStatus(projectId) {
+  const cp = readIndexCheckpoint(projectId);
+  return cp.integrity === "ok" ? cp.status : void 0;
+}
+function isRunPhase(phase) {
+  return typeof phase === "string" && INDEX_RUN_PHASES.includes(phase);
+}
+function decideResume(projectId, opts = {}) {
+  const now = opts.now ?? Date.now();
+  const maxAgeMs = opts.maxAgeMs ?? 36e5;
+  const cp = readIndexCheckpoint(projectId);
+  if (cp.integrity === "missing") {
+    return { resumable: false, reason: "no in-progress checkpoint; running incremental (only missing/changed files)" };
+  }
+  if (cp.integrity !== "ok" || !cp.status) {
+    return {
+      resumable: false,
+      // Said plainly rather than as "no checkpoint": the file is there, and a
+      // user who was told "none" cannot tell that from a project that was
+      // never interrupted. The work is unaffected (resume is derived from the
+      // store either way), but the report should not hide a damaged file.
+      reason: `checkpoint unreadable (${cp.integrity}): ${cp.problem ?? "unknown problem"}; running incremental (only missing/changed files)`
+    };
+  }
+  const s = cp.status;
+  if (!RESUMABLE_PHASES.includes(s.phase)) {
+    return { resumable: false, reason: `checkpoint phase is "${s.phase}", not resumable; running incremental (only missing/changed files)` };
+  }
+  const age = now - s.updatedAt;
+  if (age >= maxAgeMs) {
+    return {
+      resumable: false,
+      reason: `checkpoint is ${Math.round(age / 6e4)} min old (> ${Math.round(maxAgeMs / 6e4)} min), so its counts describe a tree that has since moved; running incremental (only missing/changed files)`
+    };
+  }
+  return { resumable: true, reason: `resuming interrupted index (checkpoint: ${s.processedFiles}/${s.totalFiles} files done)` };
+}
+async function readLastRun(projectId) {
+  try {
+    const raw = await BrainDatabase.getRawInstance(projectId);
+    const row = raw.prepare("SELECT performance_stats FROM brain_index_status WHERE project_id = ?").get(projectId);
+    const perf = row?.performance_stats ? JSON.parse(String(row.performance_stats)) : null;
+    if (!perf || !Array.isArray(perf.runs) || perf.runs.length === 0) return void 0;
+    const r = perf.runs[perf.runs.length - 1];
+    if (!r || typeof r !== "object") return void 0;
+    return {
+      mode: r.mode,
+      phaseTimings: r.phases ?? void 0,
+      workerCount: r.counts?.workerCount ?? void 0,
+      counts: r.counts ?? void 0,
+      totalWallMs: r.phases?.totalWallMs ?? void 0,
+      postProcessing: r.postProcessingPhases ?? void 0,
+      generatedAt: r.generatedAt ?? void 0,
+      noop: r.noop ?? void 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function composeStatus(projectId) {
+  const checkpoint = readIndexCheckpoint(projectId);
+  const live = checkpoint.integrity === "ok" ? checkpoint.status : void 0;
+  const lastRun = await readLastRun(projectId);
+  const isRunning = !!live && !TERMINAL_PHASES.includes(live.phase) && Date.now() - live.updatedAt < 3e4;
+  const dbFileExists = existsSync(BrainDatabase.getPath(projectId));
+  const dbStats = live || lastRun || dbFileExists ? await (async () => {
+    try {
+      const { BrainDatabase: DB } = await import("./database-TCTZDLE5.js");
+      const r = await DB.getRawInstance(projectId);
+      const one = (sql) => r.prepare(sql).get()?.c ?? 0;
+      return { files: one("SELECT COUNT(*) c FROM brain_file"), symbols: one("SELECT COUNT(*) c FROM brain_symbol"), relationships: one("SELECT COUNT(*) c FROM brain_relationship") };
+    } catch {
+      return { files: 0, symbols: 0, relationships: 0 };
+    }
+  })() : { files: 0, symbols: 0, relationships: 0 };
+  return { hasIndex: !!(live || lastRun) || dbStats.files > 0, live, lastRun, isRunning, checkpoint, dbStats };
+}
+function clearStatus(projectId) {
+  for (const p of [statusPath(projectId), statusTempPath(projectId)]) {
+    try {
+      if (existsSync(p)) rmSync(p);
+    } catch {
+    }
+  }
+}
+
+export {
+  INDEX_STATUS_SCHEMA_VERSION,
+  INDEX_RUN_PHASES,
+  RESUMABLE_PHASES,
+  TERMINAL_PHASES,
+  statusPath,
+  writeLiveStatus,
+  readIndexCheckpoint,
+  readLiveStatus,
+  isRunPhase,
+  decideResume,
+  readLastRun,
+  composeStatus,
+  clearStatus
+};