@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/chunk-NO3U3FJQ.js

@@ -0,0 +1,201 @@
+import {
+  BrainDatabase
+} from "./chunk-QKTRECYS.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-76RP44JG.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
+};

package/dist/chunk-OWISBAOF.js

@@ -0,0 +1,61 @@
+// src/ast/override-context.ts
+function mergeSymbolsIntoOverrideCompanion(companion, symbols) {
+  for (const s of symbols) {
+    if (!s || !s.ownerName || !s.name) continue;
+    if (String(s.kind ?? "") !== "method") continue;
+    let declared = companion.get(s.ownerName);
+    if (!declared) {
+      declared = /* @__PURE__ */ new Set();
+      companion.set(s.ownerName, declared);
+    }
+    declared.add(s.name);
+  }
+}
+function buildOverrideCompanion(symbols) {
+  const companion = /* @__PURE__ */ new Map();
+  mergeSymbolsIntoOverrideCompanion(companion, symbols);
+  return companion;
+}
+function localEdgeLabel(fqn) {
+  let cleaned = "";
+  let depth = 0;
+  for (let i = 0; i < fqn.length; i++) {
+    const c = fqn.charCodeAt(i);
+    if (c === 40) depth++;
+    else if (c === 41) {
+      if (depth > 0) depth--;
+    } else if (depth === 0) cleaned += fqn[i];
+  }
+  const segs = cleaned.split(".").filter((s) => s.length > 0);
+  if (segs.length === 0) return "";
+  const last = segs[segs.length - 1];
+  if (segs.length < 2) return last;
+  return `${segs[segs.length - 2]}.${last}`;
+}
+function localEdgeName(fqn) {
+  const label = localEdgeLabel(fqn);
+  const dot = label.lastIndexOf(".");
+  return dot > 0 ? label.slice(dot + 1) : label;
+}
+function findDeclaringParent(methodName, startParents, companion, getParents) {
+  const queue = [...startParents];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const parent = queue.shift();
+    if (seen.has(parent)) continue;
+    seen.add(parent);
+    const declared = companion.get(parent);
+    if (declared && declared.has(methodName)) return parent;
+    for (const next of getParents(parent)) {
+      if (!seen.has(next)) queue.push(next);
+    }
+  }
+  return null;
+}
+
+export {
+  buildOverrideCompanion,
+  localEdgeLabel,
+  localEdgeName,
+  findDeclaringParent
+};