@stackmemoryai/stackmemory 1.12.0 → 1.14.0

package/dist/src/core/brain/brain-store.js

@@ -0,0 +1,187 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { randomUUID } from "crypto";
+import {
+  BRAIN_TABLE,
+  DEFAULT_BRAIN_LIMIT
+} from "./types.js";
+class BrainStore {
+  db;
+  workspaceId;
+  projectId;
+  constructor(db, scope) {
+    this.db = db;
+    this.projectId = scope.projectId;
+    this.workspaceId = scope.workspaceId ?? "";
+    this.ensureTable();
+  }
+  /** Create the brain_entries table + indexes if they don't exist. */
+  ensureTable() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${BRAIN_TABLE} (
+        entry_id TEXT PRIMARY KEY,
+        workspace_id TEXT NOT NULL DEFAULT '',
+        project_id TEXT NOT NULL,
+        agent TEXT NOT NULL DEFAULT 'claude',
+        kind TEXT NOT NULL DEFAULT 'note',
+        title TEXT NOT NULL,
+        summary TEXT NOT NULL DEFAULT '',
+        conclusion TEXT NOT NULL DEFAULT '',
+        tags TEXT NOT NULL DEFAULT '[]',
+        refs TEXT NOT NULL DEFAULT '[]',
+        confidence REAL NOT NULL DEFAULT 0.7,
+        status TEXT NOT NULL DEFAULT 'active',
+        superseded_by TEXT,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS idx_brain_project ON ${BRAIN_TABLE}(project_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS idx_brain_workspace ON ${BRAIN_TABLE}(workspace_id, created_at DESC);
+    `);
+  }
+  /** Record (or upsert by entryId) a brain entry. */
+  record(input) {
+    const now = Date.now();
+    const entry = {
+      entryId: input.entryId ?? randomUUID(),
+      workspaceId: this.workspaceId,
+      projectId: this.projectId,
+      agent: input.agent ?? "claude",
+      kind: input.kind ?? "note",
+      title: input.title,
+      summary: input.summary ?? "",
+      conclusion: input.conclusion ?? "",
+      tags: input.tags ?? [],
+      refs: input.refs ?? [],
+      confidence: clamp01(input.confidence ?? 0.7),
+      status: "active",
+      createdAt: input.createdAt ?? now,
+      updatedAt: input.updatedAt ?? now
+    };
+    this.db.prepare(
+      `INSERT INTO ${BRAIN_TABLE}
+           (entry_id, workspace_id, project_id, agent, kind, title, summary,
+            conclusion, tags, refs, confidence, status, superseded_by,
+            created_at, updated_at)
+         VALUES (@entryId, @workspaceId, @projectId, @agent, @kind, @title,
+                 @summary, @conclusion, @tags, @refs, @confidence, @status,
+                 NULL, @createdAt, @updatedAt)
+         ON CONFLICT(entry_id) DO UPDATE SET
+           agent = excluded.agent,
+           kind = excluded.kind,
+           title = excluded.title,
+           summary = excluded.summary,
+           conclusion = excluded.conclusion,
+           tags = excluded.tags,
+           refs = excluded.refs,
+           confidence = excluded.confidence,
+           updated_at = excluded.updated_at`
+    ).run({
+      ...entry,
+      tags: JSON.stringify(entry.tags),
+      refs: JSON.stringify(entry.refs)
+    });
+    return entry;
+  }
+  /** Fetch a single entry by id (or unique prefix). */
+  get(entryId) {
+    const row = this.db.prepare(
+      `SELECT * FROM ${BRAIN_TABLE} WHERE entry_id = ? OR entry_id LIKE ? LIMIT 1`
+    ).get(entryId, `${entryId}%`);
+    return row ? rowToEntry(row) : null;
+  }
+  /** Search entries by scope + free text, newest first. */
+  recall(query = {}) {
+    const where = [];
+    const params = [];
+    if (query.org) {
+      where.push("workspace_id = ?");
+      params.push(this.workspaceId);
+    } else {
+      where.push("project_id = ?");
+      params.push(query.projectId ?? this.projectId);
+    }
+    if (!query.includeSuperseded) {
+      where.push("status = 'active'");
+    }
+    if (query.agent) {
+      where.push("agent = ?");
+      params.push(query.agent);
+    }
+    if (query.kind) {
+      where.push("kind = ?");
+      params.push(query.kind);
+    }
+    if (query.since) {
+      where.push("created_at >= ?");
+      params.push(query.since);
+    }
+    if (query.text) {
+      where.push(
+        "(title LIKE ? OR summary LIKE ? OR conclusion LIKE ? OR tags LIKE ?)"
+      );
+      const like = `%${query.text}%`;
+      params.push(like, like, like, like);
+    }
+    const limit = Math.max(1, query.limit ?? DEFAULT_BRAIN_LIMIT);
+    const rows = this.db.prepare(
+      `SELECT * FROM ${BRAIN_TABLE}
+         WHERE ${where.join(" AND ")}
+         ORDER BY created_at DESC
+         LIMIT ?`
+    ).all(...params, limit);
+    return rows.map(rowToEntry);
+  }
+  /** Mark `oldId` superseded by `newId`. */
+  supersede(oldId, newId) {
+    this.db.prepare(
+      `UPDATE ${BRAIN_TABLE}
+         SET status = 'superseded', superseded_by = ?, updated_at = ?
+         WHERE entry_id = ?`
+    ).run(newId, Date.now(), oldId);
+  }
+  /** Count entries in scope (for status output). */
+  count(org = false) {
+    const col = org ? "workspace_id" : "project_id";
+    const val = org ? this.workspaceId : this.projectId;
+    const row = this.db.prepare(`SELECT COUNT(*) AS n FROM ${BRAIN_TABLE} WHERE ${col} = ?`).get(val);
+    return row.n;
+  }
+}
+function rowToEntry(row) {
+  const entry = {
+    entryId: row.entry_id,
+    workspaceId: row.workspace_id,
+    projectId: row.project_id,
+    agent: row.agent,
+    kind: row.kind,
+    title: row.title,
+    summary: row.summary,
+    conclusion: row.conclusion,
+    tags: safeParse(row.tags),
+    refs: safeParse(row.refs),
+    confidence: row.confidence,
+    status: row.status,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+  if (row.superseded_by) entry.supersededBy = row.superseded_by;
+  return entry;
+}
+function safeParse(json) {
+  try {
+    const v = JSON.parse(json);
+    return Array.isArray(v) ? v.map(String) : [];
+  } catch {
+    return [];
+  }
+}
+function clamp01(n) {
+  if (Number.isNaN(n)) return 0.7;
+  return Math.max(0, Math.min(1, n));
+}
+export {
+  BrainStore
+};

package/dist/src/core/brain/brain-sync.js

@@ -0,0 +1,193 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const BRAIN_TABLE = "brain_entries";
+class BrainSync {
+  db;
+  store;
+  config;
+  constructor(db, store, config) {
+    this.db = db;
+    this.store = store;
+    this.config = {
+      timeoutMs: 3e4,
+      batchSize: 200,
+      ...config
+    };
+    this.ensureMeta();
+  }
+  ensureMeta() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS brain_sync_meta (
+        direction TEXT PRIMARY KEY,
+        cursor INTEGER NOT NULL DEFAULT 0
+      );
+    `);
+  }
+  getCursor(direction) {
+    const row = this.db.prepare("SELECT cursor FROM brain_sync_meta WHERE direction = ?").get(direction);
+    return row?.cursor ?? 0;
+  }
+  setCursor(direction, cursor) {
+    this.db.prepare(
+      `INSERT INTO brain_sync_meta (direction, cursor) VALUES (?, ?)
+         ON CONFLICT(direction) DO UPDATE SET cursor = excluded.cursor`
+    ).run(direction, cursor);
+  }
+  /** Push locally-updated entries to the cloud. */
+  async push() {
+    const since = this.getCursor("push");
+    const rows = this.db.prepare(
+      `SELECT * FROM ${BRAIN_TABLE} WHERE updated_at > ? ORDER BY updated_at ASC LIMIT ?`
+    ).all(since, this.config.batchSize);
+    if (rows.length === 0) {
+      return { success: true, pushed: 0, pulled: 0, applied: 0 };
+    }
+    const entries = rows.map(toWireEntry);
+    const maxUpdated = Math.max(...entries.map((e) => e.updatedAt));
+    try {
+      const res = await this.post("/v1/brain/push", {
+        protocolVersion: 1,
+        clientId: this.config.clientId,
+        workspaceId: this.config.workspaceId,
+        projectId: this.config.projectId,
+        since,
+        entries
+      });
+      this.setCursor("push", Math.max(maxUpdated, res.serverCursor ?? 0));
+      return {
+        success: true,
+        pushed: res.accepted ?? entries.length,
+        pulled: 0,
+        applied: 0
+      };
+    } catch (err) {
+      return {
+        success: false,
+        pushed: 0,
+        pulled: 0,
+        applied: 0,
+        error: errMsg(err)
+      };
+    }
+  }
+  /** Pull remote entries and apply them locally (newest-wins). */
+  async pull() {
+    const since = this.getCursor("pull");
+    try {
+      const res = await this.post("/v1/brain/pull", {
+        protocolVersion: 1,
+        clientId: this.config.clientId,
+        workspaceId: this.config.workspaceId,
+        projectId: this.config.projectId,
+        since,
+        limit: this.config.batchSize
+      });
+      const entries = res.entries ?? [];
+      let applied = 0;
+      let maxUpdated = since;
+      for (const remote of entries) {
+        maxUpdated = Math.max(maxUpdated, remote.updatedAt ?? 0);
+        const local = this.store.get(remote.entryId);
+        if (local && local.updatedAt >= (remote.updatedAt ?? 0)) continue;
+        this.store.record({
+          entryId: remote.entryId,
+          agent: remote.agent,
+          kind: remote.kind,
+          title: remote.title,
+          summary: remote.summary,
+          conclusion: remote.conclusion,
+          tags: remote.tags,
+          refs: remote.refs,
+          confidence: remote.confidence,
+          createdAt: remote.createdAt,
+          updatedAt: remote.updatedAt
+        });
+        applied++;
+      }
+      this.setCursor("pull", Math.max(maxUpdated, res.serverCursor ?? 0));
+      return { success: true, pushed: 0, pulled: entries.length, applied };
+    } catch (err) {
+      return {
+        success: false,
+        pushed: 0,
+        pulled: 0,
+        applied: 0,
+        error: errMsg(err)
+      };
+    }
+  }
+  /** Push then pull in one shot. */
+  async sync() {
+    const pushed = await this.push();
+    const pulled = await this.pull();
+    const error = pushed.error ?? pulled.error;
+    return {
+      success: pushed.success && pulled.success,
+      pushed: pushed.pushed,
+      pulled: pulled.pulled,
+      applied: pulled.applied,
+      ...error ? { error } : {}
+    };
+  }
+  async post(path, body) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.config.timeoutMs);
+    try {
+      const res = await fetch(`${this.config.endpoint}${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`,
+          "X-Client-Id": this.config.clientId
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        throw new Error(`${res.status} ${res.statusText}`);
+      }
+      return await res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+function toWireEntry(row) {
+  const parse = (v) => {
+    try {
+      const a = JSON.parse(String(v ?? "[]"));
+      return Array.isArray(a) ? a.map(String) : [];
+    } catch {
+      return [];
+    }
+  };
+  const entry = {
+    entryId: String(row["entry_id"]),
+    workspaceId: String(row["workspace_id"] ?? ""),
+    projectId: String(row["project_id"]),
+    agent: String(row["agent"]),
+    kind: String(row["kind"]),
+    title: String(row["title"]),
+    summary: String(row["summary"] ?? ""),
+    conclusion: String(row["conclusion"] ?? ""),
+    tags: parse(row["tags"]),
+    refs: parse(row["refs"]),
+    confidence: Number(row["confidence"] ?? 0.7),
+    status: String(row["status"] ?? "active"),
+    createdAt: Number(row["created_at"]),
+    updatedAt: Number(row["updated_at"])
+  };
+  if (row["superseded_by"]) entry.supersededBy = String(row["superseded_by"]);
+  return entry;
+}
+function errMsg(err) {
+  if (err instanceof Error) {
+    return err.name === "AbortError" ? "request timed out" : err.message;
+  }
+  return String(err);
+}
+export {
+  BrainSync
+};

package/dist/src/core/brain/index.js

@@ -0,0 +1,78 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { homedir, hostname } from "os";
+import { join } from "path";
+import { existsSync, readFileSync, mkdirSync } from "fs";
+import { createHash } from "crypto";
+import Database from "better-sqlite3";
+import { BrainStore } from "./brain-store.js";
+import { BrainSync } from "./brain-sync.js";
+import { BrainStore as BrainStore2 } from "./brain-store.js";
+import { BrainSync as BrainSync2 } from "./brain-sync.js";
+export * from "./types.js";
+const DEFAULT_ENDPOINT = "https://provenant-api.jpwu03.workers.dev";
+function readAuth() {
+  const cfgPath = join(homedir(), ".stackmemory", "config.json");
+  if (!existsSync(cfgPath)) return {};
+  try {
+    const cfg = JSON.parse(readFileSync(cfgPath, "utf8"));
+    return cfg.auth ?? {};
+  } catch {
+    return {};
+  }
+}
+function hashId(input) {
+  return createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+function resolveScope(projectDir) {
+  const auth = readAuth();
+  const projectId = process.env["PROVENANT_PROJECT_ID"] || auth.projectId || hashId(projectDir);
+  const workspaceId = process.env["PROVENANT_WORKSPACE_ID"] || auth.workspaceId || "";
+  return { projectId, workspaceId };
+}
+function resolveDbPath(projectDir) {
+  const contextDb = join(projectDir, ".stackmemory", "context.db");
+  if (existsSync(contextDb)) return contextDb;
+  const localDb = join(projectDir, ".stackmemory", "stackmemory.db");
+  if (existsSync(localDb)) return localDb;
+  const globalDb = join(homedir(), ".stackmemory", "stackmemory.db");
+  if (existsSync(globalDb)) return globalDb;
+  mkdirSync(join(projectDir, ".stackmemory"), { recursive: true });
+  return contextDb;
+}
+function openBrain(projectDir = process.cwd()) {
+  const { projectId, workspaceId } = resolveScope(projectDir);
+  const dbPath = resolveDbPath(projectDir);
+  const db = new Database(dbPath);
+  const store = new BrainStore(db, { projectId, workspaceId });
+  const auth = readAuth();
+  const apiKey = process.env["PROVENANT_API_KEY"] || auth.apiKey;
+  let sync = null;
+  if (apiKey) {
+    const syncConfig = {
+      endpoint: process.env["PROVENANT_API_URL"] || auth.apiUrl || DEFAULT_ENDPOINT,
+      apiKey,
+      workspaceId,
+      projectId,
+      clientId: hashId(hostname() + projectDir)
+    };
+    sync = new BrainSync(db, store, syncConfig);
+  }
+  return {
+    db,
+    store,
+    projectId,
+    workspaceId,
+    sync,
+    close: () => db.close()
+  };
+}
+export {
+  BrainStore2 as BrainStore,
+  BrainSync2 as BrainSync,
+  openBrain,
+  resolveDbPath,
+  resolveScope
+};

package/dist/src/core/brain/types.js

@@ -0,0 +1,10 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const BRAIN_TABLE = "brain_entries";
+const DEFAULT_BRAIN_LIMIT = 20;
+export {
+  BRAIN_TABLE,
+  DEFAULT_BRAIN_LIMIT
+};

package/dist/src/core/cache/token-estimator.js

@@ -3,14 +3,37 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { createHash } from "crypto";
+import { createRequire } from "module";
+let encoder = null;
+let initAttempted = false;
+function getEncoder() {
+  if (initAttempted) return encoder;
+  initAttempted = true;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const tiktoken = require2("js-tiktoken");
+    encoder = tiktoken.getEncoding("cl100k_base");
+  } catch {
+    encoder = null;
+  }
+  return encoder;
+}
 function estimateTokens(content) {
   if (!content) return 0;
+  const enc = getEncoder();
+  if (enc) {
+    return enc.encode(content).length;
+  }
   return Math.ceil(content.length / 4);
 }
+function isTiktokenActive() {
+  return getEncoder() !== null;
+}
 function hashContent(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 export {
   estimateTokens,
-  hashContent
+  hashContent,
+  isTiktokenActive
 };

package/dist/src/core/config/feature-flags.js

@@ -15,8 +15,7 @@ function isFeatureEnabled(feature) {
       return process.env["STACKMEMORY_AI"] !== "false" && (!!process.env["ANTHROPIC_API_KEY"] || !!process.env["OPENAI_API_KEY"]);
     case "skills":
       return process.env["STACKMEMORY_SKILLS"] === "true" || process.env["STACKMEMORY_SKILLS"] === "1";
-    case "ralph":
-      return process.env["STACKMEMORY_RALPH"] !== "false";
+    // For npm package users, must be explicitly enabled
     case "multiProvider":
       return process.env["STACKMEMORY_MULTI_PROVIDER"] === "true" || process.env["STACKMEMORY_MULTI_PROVIDER"] === "1";
     default:
@@ -29,7 +28,6 @@ function getFeatureFlags() {
     linear: isFeatureEnabled("linear"),
     aiSummaries: isFeatureEnabled("aiSummaries"),
     skills: isFeatureEnabled("skills"),
-    ralph: isFeatureEnabled("ralph"),
     multiProvider: isFeatureEnabled("multiProvider")
   };
 }
@@ -49,9 +47,7 @@ function logFeatureStatus() {
     console.log(
       `  Skills: ${flags.skills ? "enabled" : "disabled (set STACKMEMORY_SKILLS=true)"}`
     );
-    console.log(
-      `  Ralph: ${flags.ralph ? "enabled" : "disabled (set STACKMEMORY_RALPH=true)"}`
-    );
+    console.log();
     console.log(
       `  MultiProvider: ${flags.multiProvider ? "enabled" : "disabled (set STACKMEMORY_MULTI_PROVIDER=true)"}`
     );

package/dist/src/core/context/frame-database.js

@@ -208,6 +208,50 @@ class FrameDatabase {
         CREATE INDEX IF NOT EXISTS idx_entity_temporal
           ON entity_states(entity_name, valid_from DESC);
       `);
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS cloud_sync_state (
+          table_name TEXT NOT NULL,
+          row_id TEXT NOT NULL,
+          last_pushed_at INTEGER,
+          last_pushed_version INTEGER,
+          last_pulled_at INTEGER,
+          last_pulled_version INTEGER,
+          sync_status TEXT NOT NULL DEFAULT 'pending',
+          push_error TEXT,
+          push_attempts INTEGER DEFAULT 0,
+          PRIMARY KEY (table_name, row_id)
+        );
+        CREATE INDEX IF NOT EXISTS idx_cloud_sync_status ON cloud_sync_state(sync_status);
+        CREATE INDEX IF NOT EXISTS idx_cloud_sync_pushed ON cloud_sync_state(last_pushed_at);
+
+        CREATE TABLE IF NOT EXISTS cloud_sync_cursors (
+          direction TEXT PRIMARY KEY,
+          cursor_value TEXT NOT NULL,
+          updated_at INTEGER NOT NULL
+        );
+
+        -- Learned behavioral patterns (observe \u2192 learn \u2192 apply)
+        CREATE TABLE IF NOT EXISTS patterns (
+          id TEXT PRIMARY KEY,
+          domain TEXT NOT NULL,
+          trigger TEXT NOT NULL,
+          action TEXT NOT NULL,
+          evidence TEXT DEFAULT '[]',
+          confidence REAL DEFAULT 0.3,
+          observation_count INTEGER DEFAULT 0,
+          scope TEXT DEFAULT 'project',
+          project_id TEXT,
+          status TEXT DEFAULT 'pending',
+          source TEXT DEFAULT 'observed',
+          created_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+          updated_at INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+          last_matched_at INTEGER,
+          superseded_by TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_patterns_project ON patterns(project_id, status);
+        CREATE INDEX IF NOT EXISTS idx_patterns_domain ON patterns(domain, confidence DESC);
+        CREATE INDEX IF NOT EXISTS idx_patterns_status ON patterns(status, confidence DESC);
+      `);
       logger.info("Frame database schema initialized");
     } catch (error) {
       throw new DatabaseError(

package/dist/src/core/context/recursive-context-manager.js

@@ -3,6 +3,7 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { logger } from "../monitoring/logger.js";
+import { estimateTokens } from "../cache/token-estimator.js";
 import { ValidationError, ErrorCode } from "../errors/index.js";
 import * as fs from "fs";
 import * as path from "path";
@@ -381,7 +382,6 @@ class RecursiveContextManager {
   fitChunksToTokenBudget(chunks, _maxTokens) {
     const selected = [];
     let totalTokens = 0;
-    const estimateTokens = (text) => Math.ceil(text.length / 4);
     for (const chunk of chunks) {
       const chunkTokens = estimateTokens(chunk.content);
       if (totalTokens + chunkTokens <= maxTokens) {

package/dist/src/core/context/rehydration.js

@@ -5,6 +5,7 @@ const __dirname = __pathDirname(__filename);
 import * as fs from "fs/promises";
 import * as path from "path";
 import { logger } from "../monitoring/logger.js";
+import { estimateTokens } from "../cache/token-estimator.js";
 import {
   getModelTokenLimit
 } from "../models/model-router.js";
@@ -44,7 +45,7 @@ class CompactionHandler {
    * Track token usage from a message
    */
   trackTokens(content) {
-    const estimatedTokens = Math.ceil(content.length / 4);
+    const estimatedTokens = estimateTokens(content);
     this.tokenAccumulator += estimatedTokens;
     this.metrics.estimatedTokens += estimatedTokens;
     if (this.isApproachingCompaction()) {

package/dist/src/core/database/sqlite-adapter.js

@@ -44,7 +44,20 @@ class SQLiteAdapter extends FeatureAwareDatabaseAdapter {
     const config = this.config;
     const dir = path.dirname(this.dbPath);
     await fs.mkdir(dir, { recursive: true });
-    this.db = new Database(this.dbPath);
+    try {
+      this.db = new Database(this.dbPath);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      if (msg.includes("NODE_MODULE_VERSION") || msg.includes("was compiled against a different Node.js version")) {
+        const nodeVersion = process.version;
+        throw new Error(
+          `better-sqlite3 was compiled for a different Node.js version than the one currently running (${nodeVersion}).
+Fix: cd ${process.cwd()} && npm rebuild better-sqlite3
+If that fails: npm install`
+        );
+      }
+      throw err;
+    }
     this.db.pragma("foreign_keys = ON");
     if (config.walMode !== false) {
       this.db.pragma("journal_mode = WAL");