@backbencher/brain 0.0.0-stage → 0.1.0

package/dist/chunk-D2Q4Y47A.js

@@ -0,0 +1,53 @@
+// src/ast/scoped-path.ts
+import { existsSync, realpathSync, statSync } from "fs";
+import path from "path";
+function canonicalProjectRoot(projectPath) {
+  const resolved = path.resolve(projectPath);
+  try {
+    return realpathSync.native(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function isInsideProject(absolute, projectRoot) {
+  if (absolute === projectRoot) return true;
+  return absolute.startsWith(projectRoot + path.sep);
+}
+function resolveScopedProjectFile(projectPath, input) {
+  const projectRoot = canonicalProjectRoot(projectPath);
+  const raw = typeof input === "string" ? input.trim() : "";
+  if (raw.length === 0) return { ok: false, reason: "empty-path", resolved: projectRoot, projectRoot };
+  const lexical = path.resolve(projectRoot, raw);
+  if (!isInsideProject(lexical, projectRoot)) {
+    return { ok: false, reason: "outside-project", resolved: lexical, projectRoot };
+  }
+  let canonical = lexical;
+  try {
+    canonical = realpathSync.native(lexical);
+  } catch {
+    return { ok: false, reason: "not-found", resolved: lexical, projectRoot };
+  }
+  if (!isInsideProject(canonical, projectRoot)) {
+    return { ok: false, reason: "outside-project", resolved: canonical, projectRoot };
+  }
+  try {
+    if (!statSync(canonical).isFile()) return { ok: false, reason: "not-a-file", resolved: canonical, projectRoot };
+  } catch {
+    return { ok: false, reason: "not-found", resolved: canonical, projectRoot };
+  }
+  if (!existsSync(canonical)) return { ok: false, reason: "not-found", resolved: canonical, projectRoot };
+  return { ok: true, absolute: canonical };
+}
+function describeScopedPathRefusal(result) {
+  const where = `(resolved against ${result.projectRoot})`;
+  if (result.reason === "empty-path") return `--file path is empty ${where}`;
+  if (result.reason === "not-found") return `--file not found: ${result.resolved} ${where}`;
+  if (result.reason === "not-a-file") return `--file is not a file: ${result.resolved} ${where}`;
+  return `--file is outside the project: ${result.resolved}; the project root is ${result.projectRoot}`;
+}
+
+export {
+  canonicalProjectRoot,
+  resolveScopedProjectFile,
+  describeScopedPathRefusal
+};

package/dist/chunk-DIYAGQJL.js

@@ -0,0 +1,34 @@
+import {
+  bbProjectsDir
+} from "./chunk-2BSKD7O3.js";
+
+// src/util/project-id.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, realpathSync, renameSync } from "fs";
+import path from "path";
+function getProjectId(projectPath) {
+  const resolved = path.resolve(projectPath);
+  let canonical = resolved;
+  try {
+    canonical = realpathSync.native(resolved);
+  } catch {
+  }
+  const canonicalId = createHash("sha1").update(canonical).digest("hex").substring(0, 40);
+  if (canonical !== resolved) {
+    const legacyId = createHash("sha1").update(resolved).digest("hex").substring(0, 40);
+    const legacyDir = path.join(bbProjectsDir(), legacyId);
+    const canonicalDir = path.join(bbProjectsDir(), canonicalId);
+    if (existsSync(legacyDir) && !existsSync(canonicalDir)) {
+      mkdirSync(bbProjectsDir(), { recursive: true });
+      try {
+        renameSync(legacyDir, canonicalDir);
+      } catch {
+      }
+    }
+  }
+  return canonicalId;
+}
+
+export {
+  getProjectId
+};

package/dist/chunk-DYM4FQEE.js

@@ -0,0 +1,90 @@
+// src/ast/index-space.ts
+import { statSync } from "fs";
+function runPragma(rawDb, body) {
+  const driver = rawDb?.native ?? rawDb;
+  if (typeof driver?.pragma === "function") return driver.pragma(body);
+  if (typeof driver?.prepare === "function") {
+    const stmt = driver.prepare(`PRAGMA ${body}`);
+    if (typeof stmt?.all === "function") {
+      const rows = stmt.all();
+      return Array.isArray(rows) ? rows : [rows];
+    }
+  }
+  return void 0;
+}
+function checkpointWal(rawDb) {
+  try {
+    const result = runPragma(rawDb, "wal_checkpoint(TRUNCATE)");
+    const row = Array.isArray(result) ? result[0] : result;
+    if (row && typeof row === "object" && "busy" in row) return Number(row.busy) === 0;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function spaceReport(rawDb, dbPath) {
+  let dbBytes = 0;
+  let walBytes = 0;
+  try {
+    dbBytes = statSync(dbPath).size;
+  } catch {
+  }
+  try {
+    walBytes = statSync(`${dbPath}-wal`).size;
+  } catch {
+  }
+  let freelistBytes = 0;
+  let freeRatio = 0;
+  try {
+    const freeRow = runPragma(rawDb, "freelist_count");
+    const pageRow = runPragma(rawDb, "page_size");
+    const first = (row, key) => Array.isArray(row) ? row[0]?.[key] : row?.[key];
+    const free = Number(first(freeRow, "freelist_count") ?? 0);
+    const pageSize = Number(first(pageRow, "page_size") ?? 0);
+    freelistBytes = free * pageSize;
+    freeRatio = dbBytes > 0 ? freelistBytes / dbBytes : 0;
+  } catch {
+  }
+  return { dbBytes, walBytes, freelistBytes, freeRatio, checkpointed: false, vacuumed: false, vacuumMs: null };
+}
+function shouldVacuumAfterWipe(input) {
+  const minBytes = input.minBytes ?? 256 * 1024 * 1024;
+  return input.rowsDeleted > 0 && input.dbBytes >= minBytes;
+}
+function reclaimSpace(rawDb, dbPath, opts = {}) {
+  const checkpointed = checkpointWal(rawDb);
+  const before = spaceReport(rawDb, dbPath);
+  const ratioFloor = opts.vacuumAboveRatio ?? 0.25;
+  const byteFloor = opts.vacuumAboveBytes ?? 64 * 1024 * 1024;
+  const wantVacuum = opts.vacuum === true && before.freelistBytes >= byteFloor && before.freeRatio >= ratioFloor;
+  let vacuumed = false;
+  let vacuumMs = null;
+  if (wantVacuum && process.env.BB_INDEX_VACUUM !== "0") {
+    const started = Date.now();
+    try {
+      rawDb.exec("VACUUM");
+      vacuumed = true;
+    } catch (e) {
+      opts.log?.("VACUUM skipped", { error: String(e?.message ?? e) });
+    }
+    vacuumMs = Date.now() - started;
+    if (vacuumed) checkpointWal(rawDb);
+  }
+  const after = spaceReport(rawDb, dbPath);
+  return { ...after, checkpointed, vacuumed, vacuumMs };
+}
+function formatSpace(report) {
+  const mb = (n) => `${(n / 1024 / 1024).toFixed(1)} MB`;
+  const parts = [`db ${mb(report.dbBytes)}`, `wal ${mb(report.walBytes)}`];
+  if (report.freeRatio > 0) parts.push(`${(report.freeRatio * 100).toFixed(0)}% free`);
+  if (report.vacuumed && report.vacuumMs !== null) parts.push(`vacuumed in ${(report.vacuumMs / 1e3).toFixed(1)}s`);
+  return parts.join(", ");
+}
+
+export {
+  checkpointWal,
+  spaceReport,
+  shouldVacuumAfterWipe,
+  reclaimSpace,
+  formatSpace
+};

package/dist/chunk-EWMWK7WN.js

@@ -0,0 +1,75 @@
+// src/ast/file-claim.ts
+import { statSync } from "fs";
+import * as path from "path";
+var FILE_CLAIM_MAX_BYTES = 1 * 1024 * 1024;
+var NOT_A_PLAIN_PATH = [" ", "	", "*", "?", "<", ">", "|", "{", "}", "$"];
+function foldProjectPath(baseDir, written) {
+  const rel = projectRelativeOf(baseDir, written);
+  return rel !== null && rel.length > 0 ? rel : null;
+}
+function projectRelativeOf(baseDir, written) {
+  const w = written.trim();
+  if (w.length === 0 || w.length > 300) return null;
+  if (w.includes("://") || w.startsWith("/") || w.startsWith("~") || w.startsWith("\\")) return null;
+  for (const ch of NOT_A_PLAIN_PATH) if (w.includes(ch)) return null;
+  const out = [];
+  for (const seg of (baseDir + w).split("/")) {
+    if (seg.length === 0 || seg === ".") continue;
+    if (seg === "..") {
+      if (out.length === 0) return null;
+      out.pop();
+      continue;
+    }
+    out.push(seg);
+  }
+  return out.join("/");
+}
+function dirOf(rel) {
+  const i = rel.lastIndexOf("/");
+  return i < 0 ? "" : rel.slice(0, i + 1);
+}
+var extOf = (rel) => {
+  const dot = rel.lastIndexOf(".");
+  const slash = rel.lastIndexOf("/");
+  return dot > slash && dot >= 0 ? rel.slice(dot + 1).toLowerCase() : "";
+};
+function fileClaimForTarget(input) {
+  const { projectRoot, filePath, admittedExtensions } = input;
+  if (projectRoot.length === 0 || admittedExtensions.length === 0) return null;
+  let written = input.written.trim();
+  if (written.length === 0) return null;
+  const magic = input.magicConstants;
+  if (magic) {
+    for (const key of Object.keys(magic).sort((a, b) => b.length - a.length)) {
+      if (key.length > 0) written = written.split(key).join(magic[key]);
+    }
+  }
+  const root = path.resolve(projectRoot);
+  const fileRel = path.relative(root, filePath).split(path.sep).join("/");
+  const candidates = [];
+  for (const c of [foldProjectPath(dirOf(fileRel), written), foldProjectPath("", written), ...input.extraCandidates ?? []]) {
+    if (c !== null && c.length > 0 && !candidates.includes(c)) candidates.push(c);
+  }
+  const admitted = new Set(admittedExtensions.map((e) => e.replace(/^\./, "").toLowerCase()));
+  for (const candidate of candidates) {
+    if (candidate === ".." || candidate.startsWith("../")) continue;
+    if (!admitted.has(extOf(candidate))) continue;
+    try {
+      const st = statSync(path.join(root, candidate));
+      if (!st.isFile()) continue;
+      if (input.maxFileSizeBytes !== void 0 && st.size > input.maxFileSizeBytes) continue;
+    } catch {
+      continue;
+    }
+    return candidate;
+  }
+  return null;
+}
+
+export {
+  FILE_CLAIM_MAX_BYTES,
+  foldProjectPath,
+  projectRelativeOf,
+  dirOf,
+  fileClaimForTarget
+};