@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/project-health-6XPENVAA.js

@@ -0,0 +1,94 @@
+import {
+  BrainDatabase
+} from "./chunk-QKTRECYS.js";
+import {
+  create
+} from "./chunk-BQ3OVQ3P.js";
+import "./chunk-2BSKD7O3.js";
+import {
+  BrainFileTable,
+  BrainProjectHealthTable,
+  BrainSymbolTable
+} from "./chunk-ROMM6KMC.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/project-health.ts
+import { eq, sql, and, desc } from "drizzle-orm";
+var log = create({ service: "project-health" });
+async function computeAndStoreProjectHealth(projectId) {
+  const db = await BrainDatabase.getInstance(projectId);
+  const symbolCounts = await db.select({
+    type: BrainSymbolTable.symbol_type,
+    count: sql`count(*)`,
+    avgComplexity: sql`avg(${BrainSymbolTable.complexity})`
+  }).from(BrainSymbolTable).where(eq(BrainSymbolTable.project_id, projectId)).groupBy(BrainSymbolTable.symbol_type);
+  const langCounts = await db.select({
+    language: BrainFileTable.language,
+    count: sql`count(*)`,
+    lines: sql`sum(${BrainFileTable.line_count})`
+  }).from(BrainFileTable).where(eq(BrainFileTable.project_id, projectId)).groupBy(BrainFileTable.language);
+  const complexFunctions = await db.select({
+    name: BrainSymbolTable.name,
+    complexity: BrainSymbolTable.complexity,
+    file: BrainFileTable.relative_path
+  }).from(BrainSymbolTable).innerJoin(BrainFileTable, eq(BrainSymbolTable.file_id, BrainFileTable.id)).where(
+    and(
+      eq(BrainSymbolTable.project_id, projectId),
+      eq(BrainSymbolTable.symbol_type, "function"),
+      sql`${BrainSymbolTable.complexity} > 10`
+    )
+  ).orderBy(desc(BrainSymbolTable.complexity)).limit(20);
+  const totalSymbols = symbolCounts.reduce((acc, s) => acc + (s.count || 0), 0);
+  const totalLines = langCounts.reduce((acc, l) => acc + (l.lines || 0), 0);
+  const avgComplexity = symbolCounts.find((s) => s.type === "function")?.avgComplexity || 1;
+  const complexityScore = Math.max(0, Math.min(100, 100 - avgComplexity * 5));
+  const functionCount = symbolCounts.find((s) => s.type === "function")?.count || 0;
+  const classCount = symbolCounts.find((s) => s.type === "class")?.count || 0;
+  const ratio = classCount > 0 ? functionCount / classCount : functionCount / 10;
+  const maintainabilityScore = Math.max(0, Math.min(100, 100 - Math.abs(ratio - 5) * 5));
+  const highComplexityCount = complexFunctions.length;
+  const techDebtScore = Math.max(0, 100 - highComplexityCount * 5);
+  const codeQualityScore = Math.round((complexityScore + maintainabilityScore + techDebtScore) / 3);
+  const langDist = langCounts.filter((l) => l.language).map((l) => ({
+    language: l.language,
+    files: l.count,
+    lines: l.lines,
+    percentage: totalLines > 0 ? Math.round(l.lines / totalLines * 100) : 0
+  }));
+  const bottlenecks = complexFunctions.map((f) => `${f.name} (complexity: ${f.complexity}) in ${f.file}`);
+  const existing = await db.select().from(BrainProjectHealthTable).where(eq(BrainProjectHealthTable.project_id, projectId)).limit(1);
+  const healthData = {
+    project_id: projectId,
+    complexity_score: Math.round(complexityScore),
+    maintainability_score: Math.round(maintainabilityScore),
+    technical_debt_score: Math.round(techDebtScore),
+    code_quality_score: codeQualityScore,
+    language_distribution: JSON.stringify(langDist),
+    service_metrics: JSON.stringify([]),
+    dependency_metrics: JSON.stringify({ total: totalSymbols, external: 0 }),
+    circular_dependencies: JSON.stringify([]),
+    contract_drift: JSON.stringify([]),
+    performance_bottlenecks: JSON.stringify(bottlenecks),
+    time_updated: Date.now()
+  };
+  if (existing.length > 0) {
+    await db.update(BrainProjectHealthTable).set(healthData).where(eq(BrainProjectHealthTable.project_id, projectId));
+  } else {
+    await db.insert(BrainProjectHealthTable).values({
+      ...healthData,
+      time_created: Date.now()
+    });
+  }
+  log.info("project health computed", {
+    projectId,
+    complexityScore: Math.round(complexityScore),
+    maintainabilityScore: Math.round(maintainabilityScore),
+    techDebtScore: Math.round(techDebtScore),
+    codeQualityScore,
+    languages: langDist.length,
+    bottlenecks: bottlenecks.length
+  });
+}
+export {
+  computeAndStoreProjectHealth
+};

package/dist/project-index-5SDPHITE.js

@@ -0,0 +1,57 @@
+import {
+  CLOJURE_DECLARATION_FORMS,
+  CLOJURE_DECLARATION_SPEC,
+  CPP_DECLARATION_SPEC,
+  DART_DECLARATION_SPEC,
+  FSHARP_DECLARATION_SPEC,
+  JAVASCRIPT_DECLARATION_SPEC,
+  JAVA_DECLARATION_SPEC,
+  PYTHON_DECLARATION_SPEC,
+  RUBY_DECLARATION_SPEC,
+  SCSS_DECLARATION_SPEC,
+  SOLIDITY_DECLARATION_SPEC,
+  TYPESCRIPT_DECLARATION_SPEC,
+  buildProjectIndex,
+  buildProjectIndexFromDisk,
+  buildProjectIndexStreaming,
+  buildResolutionTables,
+  clojureDeclarationName,
+  clojureExecutionHead,
+  clojureFileNamespace,
+  clojureSymName,
+  deserializeProjectIndex,
+  emptyProjectIndex,
+  enrichWithProjectIndex,
+  indexTree,
+  roundTripProjectIndex,
+  serializeProjectIndex
+} from "./chunk-2DE27DVC.js";
+import "./chunk-MLKGABMK.js";
+export {
+  CLOJURE_DECLARATION_FORMS,
+  CLOJURE_DECLARATION_SPEC,
+  CPP_DECLARATION_SPEC,
+  DART_DECLARATION_SPEC,
+  FSHARP_DECLARATION_SPEC,
+  JAVASCRIPT_DECLARATION_SPEC,
+  JAVA_DECLARATION_SPEC,
+  PYTHON_DECLARATION_SPEC,
+  RUBY_DECLARATION_SPEC,
+  SCSS_DECLARATION_SPEC,
+  SOLIDITY_DECLARATION_SPEC,
+  TYPESCRIPT_DECLARATION_SPEC,
+  buildProjectIndex,
+  buildProjectIndexFromDisk,
+  buildProjectIndexStreaming,
+  buildResolutionTables,
+  clojureDeclarationName,
+  clojureExecutionHead,
+  clojureFileNamespace,
+  clojureSymName,
+  deserializeProjectIndex,
+  emptyProjectIndex,
+  enrichWithProjectIndex,
+  indexTree,
+  roundTripProjectIndex,
+  serializeProjectIndex
+};

package/dist/project-registry-ZJ3DVUGO.js

@@ -0,0 +1,355 @@
+import {
+  computeDbFingerprint,
+  readStoredFingerprint
+} from "./chunk-7MBYT777.js";
+import {
+  liveIndexLockHolder
+} from "./chunk-ZETTGPAW.js";
+import "./chunk-4H22TLOT.js";
+import "./chunk-GEFFO6O2.js";
+import {
+  clearStatus,
+  readLiveStatus,
+  writeLiveStatus
+} from "./chunk-NO3U3FJQ.js";
+import "./chunk-DYM4FQEE.js";
+import {
+  BrainDatabase
+} from "./chunk-QKTRECYS.js";
+import "./chunk-3ZTOHHSW.js";
+import "./chunk-BQ3OVQ3P.js";
+import "./chunk-SK6YVHFZ.js";
+import {
+  bbProjectsDir
+} from "./chunk-2BSKD7O3.js";
+import "./chunk-KAET47ZL.js";
+import "./chunk-KCDECRJY.js";
+import "./chunk-D2Q4Y47A.js";
+import "./chunk-SM7RFQRO.js";
+import "./chunk-L5TDYKYK.js";
+import "./chunk-ROMM6KMC.js";
+import "./chunk-MLKGABMK.js";
+
+// src/ast/project-registry.ts
+import { readdirSync, statSync, existsSync, rmSync, copyFileSync, mkdirSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+var require2 = createRequire(import.meta.url);
+function commonRoot(paths) {
+  if (paths.length === 0) return null;
+  let prefix = paths[0];
+  for (const p of paths.slice(1)) {
+    while (!p.startsWith(prefix)) {
+      const idx = prefix.lastIndexOf("/");
+      if (idx <= 0) return "/";
+      prefix = prefix.slice(0, idx);
+    }
+  }
+  return prefix;
+}
+function dbIndexedRoot(raw) {
+  try {
+    const rows = raw.prepare("SELECT path FROM brain_file").all();
+    const abs = rows.map((r) => String(r.path)).filter((p) => p.startsWith("/"));
+    if (abs.length === 0) return null;
+    const root = commonRoot(abs);
+    return root && root !== "/" ? root : null;
+  } catch {
+    return null;
+  }
+}
+function listProjects() {
+  const dir = bbProjectsDir();
+  if (!existsSync(dir)) return [];
+  const entries = [];
+  for (const id of readdirSync(dir)) {
+    if (!/^[0-9a-f]{40}$/.test(id)) continue;
+    const dbPath = path.join(dir, id, "brain.db");
+    if (!existsSync(dbPath)) continue;
+    let sizeBytes = 0;
+    try {
+      sizeBytes = statSync(dbPath).size;
+    } catch {
+    }
+    let files = 0, symbols = 0, lastIndexed = null, status = null, humanPath = null;
+    let unreadable = null;
+    try {
+      const row = BrainDatabase.openByPath(dbPath, { readonly: true });
+      const meta = row.prepare("SELECT total_files, total_symbols, time_updated, status FROM brain_index_status WHERE project_id = ?").get(id);
+      if (meta) {
+        files = Number(meta.total_files ?? 0);
+        symbols = Number(meta.total_symbols ?? 0);
+        lastIndexed = meta.time_updated ? Number(meta.time_updated) : null;
+        status = meta.status ?? null;
+        if (files === 0 && symbols === 0) {
+          files = Number(row.prepare("SELECT COUNT(*) c FROM brain_file").get()?.c ?? 0);
+          symbols = Number(row.prepare("SELECT COUNT(*) c FROM brain_symbol").get()?.c ?? 0);
+        }
+      } else {
+        files = Number(row.prepare("SELECT COUNT(*) c FROM brain_file").get()?.c ?? 0);
+        symbols = Number(row.prepare("SELECT COUNT(*) c FROM brain_symbol").get()?.c ?? 0);
+      }
+      const sample = row.prepare("SELECT path FROM brain_file LIMIT 300").all().map((r) => String(r.path));
+      humanPath = commonRoot(sample);
+    } catch (error) {
+      unreadable = String(error?.message ?? error).slice(0, 200);
+    }
+    entries.push({ id, dbPath, dbSizeBytes: sizeBytes, files, symbols, lastIndexed, status, humanPath, unreadable });
+  }
+  return entries;
+}
+function resolveProjectId(prefix) {
+  const p = prefix.trim().toLowerCase();
+  if (!/^[0-9a-f]{1,40}$/.test(p)) return null;
+  if (p.length === 40) return existsSync(path.join(bbProjectsDir(), p)) ? p : null;
+  let match = null;
+  let ambiguous = false;
+  try {
+    for (const entry of readdirSync(bbProjectsDir(), { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      if (!entry.name.startsWith(p)) continue;
+      if (match) {
+        ambiguous = true;
+        break;
+      }
+      match = entry.name;
+    }
+  } catch {
+    return null;
+  }
+  return ambiguous ? null : match;
+}
+function removeProject(id, force) {
+  const resolved = resolveProjectId(id);
+  if (!resolved) {
+    const p = id.trim().toLowerCase();
+    if (/^[0-9a-f]{1,40}$/.test(p)) {
+      let hits = 0;
+      try {
+        for (const entry of readdirSync(bbProjectsDir(), { withFileTypes: true })) {
+          if (entry.isDirectory() && entry.name.startsWith(p)) hits++;
+        }
+      } catch {
+      }
+      if (hits > 1) {
+        return { id, removed: false, reason: `project id ${p} is ambiguous (${hits} matches) \u2014 use more characters` };
+      }
+    }
+    return { id, removed: false, reason: `no project with id ${id.slice(0, 8)}` };
+  }
+  const id2 = resolved;
+  const dir = path.join(bbProjectsDir(), id2);
+  const live = readLiveStatus(id2);
+  const inFlight = !!live && live.phase === "indexing" && Date.now() - live.updatedAt < 36e5;
+  const lockHolder = liveIndexLockHolder(id2);
+  if ((inFlight || lockHolder) && !force) {
+    const reason = lockHolder ? `project is being indexed by pid ${lockHolder.pid} (index lock held); use --force to remove anyway` : `project is being indexed (in-flight); use --force to remove anyway`;
+    return { id: id2, removed: false, reason };
+  }
+  try {
+    try {
+      const raw = BrainDatabase.openByPath(path.join(dir, "brain.db"));
+      const { wipeProjectData } = require2("./parallel-indexer");
+      wipeProjectData(raw);
+      raw.close();
+    } catch {
+    }
+    rmSync(dir, { recursive: true, force: true });
+    clearStatus(id2);
+    return { id: id2, removed: !existsSync(dir) };
+  } catch (e) {
+    return { id: id2, removed: false, reason: e?.message ?? String(e) };
+  }
+}
+function totalProjectsBytes(entries) {
+  return entries.reduce((a, e) => a + e.dbSizeBytes, 0);
+}
+function findAdoptableDb(checkoutFingerprint) {
+  const dir = bbProjectsDir();
+  if (!existsSync(dir)) return null;
+  for (const id of readdirSync(dir)) {
+    if (!/^[0-9a-f]{40}$/.test(id)) continue;
+    const dbPath = path.join(dir, id, "brain.db");
+    if (!existsSync(dbPath)) continue;
+    try {
+      const raw = BrainDatabase.openByPath(dbPath, { readonly: true });
+      const stored = readStoredFingerprint(raw, id);
+      let fp = stored;
+      let git = null;
+      try {
+        const row = raw.prepare("SELECT codebase_git FROM brain_index_status WHERE project_id = ?").get(id);
+        git = row?.codebase_git ?? null;
+      } catch {
+      }
+      if (!fp) {
+        try {
+          fp = computeDbFingerprint(raw, git);
+        } catch {
+          continue;
+        }
+      }
+      if (fp && fp === checkoutFingerprint) {
+        const live = dbIndexedRoot(raw);
+        if (live && existsSync(live)) continue;
+        const files = Number(raw.prepare("SELECT COUNT(*) c FROM brain_file").get()?.c ?? 0);
+        return { id, dbPath, fingerprint: fp, git, files };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function adoptProject(fromId, toId, newPath) {
+  if (!/^[0-9a-f]{40}$/.test(fromId) || !/^[0-9a-f]{40}$/.test(toId)) {
+    return { adopted: false, toId, reason: "invalid project id" };
+  }
+  if (fromId === toId) {
+    return { adopted: false, toId, reason: "source and target ids are identical" };
+  }
+  const srcDb = path.join(bbProjectsDir(), fromId, "brain.db");
+  return importDbFile(srcDb, toId, newPath, { fromId, dropSource: true });
+}
+function importDbFile(dbFilePath, toId, newPath, opts = {}) {
+  if (!/^[0-9a-f]{40}$/.test(toId)) {
+    return { adopted: false, toId, reason: "invalid project id" };
+  }
+  const src = path.resolve(dbFilePath);
+  if (!existsSync(src)) {
+    return { adopted: false, toId, reason: `no such DB file: ${src}` };
+  }
+  const dstDir = path.join(bbProjectsDir(), toId);
+  const dstDb = path.join(dstDir, "brain.db");
+  if (existsSync(dstDir)) {
+    return { adopted: false, toId, reason: `target project ${toId.slice(0, 8)} already has an index` };
+  }
+  const fromId = opts.fromId ?? projectIdFromDbFile(src);
+  try {
+    let isBrainDb = false;
+    try {
+      const probe = BrainDatabase.openByPath(src, { readonly: true });
+      try {
+        const t = probe.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='brain_file'").get();
+        isBrainDb = !!t;
+      } finally {
+        BrainDatabase.closeByPath(src);
+      }
+    } catch {
+      BrainDatabase.closeByPath(src);
+    }
+    if (!isBrainDb) return { adopted: false, toId, reason: `not a brain DB (no brain_file table): ${src}` };
+    mkdirSync(dstDir, { recursive: true });
+    try {
+      BrainDatabase.openByPath(src).exec("PRAGMA wal_checkpoint(TRUNCATE)");
+      BrainDatabase.closeByPath(src);
+    } catch {
+      BrainDatabase.closeByPath(src);
+      for (const suffix of ["-wal", "-shm"]) {
+        if (existsSync(src + suffix)) copyFileSync(src + suffix, dstDb + suffix);
+      }
+    }
+    copyFileSync(src, dstDb);
+    const raw = BrainDatabase.openByPath(dstDb);
+    if (fromId && fromId !== toId) {
+      try {
+        raw.prepare("PRAGMA foreign_keys = OFF").run();
+      } catch {
+      }
+      const projectScoped = [
+        "brain_file",
+        "brain_symbol",
+        "brain_relationship",
+        "brain_import",
+        "brain_query_cache",
+        "brain_project_health",
+        "brain_taint_flow",
+        "brain_semantic_embedding",
+        "brain_analysis_run",
+        "brain_analysis_finding",
+        "brain_analysis_occurrence",
+        "brain_index_status",
+        "brain_annotation"
+      ];
+      for (const table of projectScoped) {
+        try {
+          raw.prepare(`UPDATE ${table} SET project_id = ? WHERE project_id = ?`).run(toId, fromId);
+        } catch {
+        }
+      }
+      rekeyEmbeddedIds(raw, fromId, toId, projectScoped);
+    }
+    rewriteBrainFilePaths(raw, newPath);
+    raw.close();
+    if (fromId) {
+      const live = readLiveStatus(fromId);
+      if (live) {
+        writeLiveStatus(toId, { ...live, projectId: toId });
+        clearStatus(fromId);
+      }
+    }
+    if (opts.dropSource) {
+      rmSync(path.dirname(src), { recursive: true, force: true });
+    }
+    return { adopted: true, fromId: fromId ?? void 0, toId };
+  } catch (e) {
+    try {
+      rmSync(dstDir, { recursive: true, force: true });
+    } catch {
+    }
+    return { adopted: false, toId, reason: e?.message ?? String(e) };
+  }
+}
+function rekeyEmbeddedIds(raw, fromId, toId, tables) {
+  const isIdColumn = (name) => name !== "project_id" && (name === "id" || name === "entity_id" || name.endsWith("_id"));
+  for (const table of tables) {
+    try {
+      const cols = raw.prepare(`PRAGMA table_info(${table})`).all().map((c) => c.name).filter(isIdColumn);
+      for (const col of cols) {
+        try {
+          raw.prepare(
+            `UPDATE ${table} SET ${col} = ? || substr(${col}, length(?) + 1) WHERE ${col} LIKE ? ESCAPE '\\'`
+          ).run(toId, fromId, `${fromId}:%`);
+        } catch {
+        }
+      }
+    } catch {
+    }
+  }
+}
+function projectIdFromDbFile(dbFilePath) {
+  const parent = path.basename(path.dirname(path.resolve(dbFilePath)));
+  if (/^[0-9a-f]{40}$/.test(parent)) return parent;
+  try {
+    const probe = BrainDatabase.openByPath(dbFilePath, { readonly: true });
+    try {
+      const row = probe.prepare("SELECT project_id FROM brain_file LIMIT 1").get();
+      if (row?.project_id && /^[0-9a-f]{40}$/.test(row.project_id)) return row.project_id;
+    } finally {
+      BrainDatabase.closeByPath(dbFilePath);
+    }
+  } catch {
+  }
+  return null;
+}
+function rewriteBrainFilePaths(raw, newPath) {
+  try {
+    const sample = raw.prepare("SELECT path FROM brain_file").all().map((r) => String(r.path));
+    const oldRoot = commonRoot(sample);
+    if (oldRoot && oldRoot !== "/" && newPath) {
+      const escaped = oldRoot.replace(/[\\%_]/g, (c) => `\\${c}`) + "%";
+      raw.prepare(
+        "UPDATE brain_file SET path = ? || SUBSTR(path, LENGTH(?) + 1) WHERE path LIKE ? ESCAPE '\\'"
+      ).run(newPath, oldRoot, escaped);
+    }
+  } catch {
+  }
+}
+export {
+  adoptProject,
+  findAdoptableDb,
+  importDbFile,
+  listProjects,
+  removeProject,
+  resolveProjectId,
+  totalProjectsBytes
+};