mnemosyne-core 2.0.0 → 2.0.2

package/dist/cli/index.mjs

@@ -3554,9 +3554,22 @@ function loadConfig() {
     return defaultConfig();
   }
 }
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(resolve(__dirname, "../package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    try {
+      const pkg = JSON.parse(readFileSync(resolve(process.cwd(), "package.json"), "utf-8"));
+      return pkg.version;
+    } catch {
+      return "2.0.1";
+    }
+  }
+}
 function defaultConfig() {
   return {
-    server: { port: 7321, host: "localhost", version: "2.0.0" },
+    server: { port: 7321, host: "localhost", version: getVersion() },
     database: { path: "data/nexus.db", wal_mode: true, vec_extension_path: "data/vec0" },
     storage: { files_dir: "data/files", max_file_size_mb: 50, backups_dir: "data/backups", backup_interval_hours: 24, max_backups: 7 },
     limits: { max_atoms_per_project: 1e4, rate_limit_requests: 100, rate_limit_window_ms: 6e4 },
@@ -4355,7 +4368,7 @@ var require_filesystem = __commonJS({
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync9 = (path) => {
+    var readFileSync7 = (path) => {
       const fd = fs.openSync(path, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
       const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
@@ -4380,7 +4393,7 @@ var require_filesystem = __commonJS({
     module2.exports = {
       LDD_PATH,
       SELF_PATH,
-      readFileSync: readFileSync9,
+      readFileSync: readFileSync7,
       readFile
     };
   }
@@ -4429,7 +4442,7 @@ var require_detect_libc = __commonJS({
     "use strict";
     var childProcess = __require("child_process");
     var { isLinux, getReport } = require_process();
-    var { LDD_PATH, SELF_PATH, readFile, readFileSync: readFileSync9 } = require_filesystem();
+    var { LDD_PATH, SELF_PATH, readFile, readFileSync: readFileSync7 } = require_filesystem();
     var { interpreterPath } = require_elf();
     var cachedFamilyInterpreter;
     var cachedFamilyFilesystem;
@@ -4521,7 +4534,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync9(LDD_PATH);
+        const lddContent = readFileSync7(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -4546,7 +4559,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyInterpreter = null;
       try {
-        const selfContent = readFileSync9(SELF_PATH);
+        const selfContent = readFileSync7(SELF_PATH);
         const path = interpreterPath(selfContent);
         cachedFamilyInterpreter = familyFromInterpreterPath(path);
       } catch (e) {
@@ -4610,7 +4623,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = readFileSync9(LDD_PATH);
+        const lddContent = readFileSync7(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -13100,7 +13113,6 @@ import { resolve as resolve9 } from "path";
 
 // src/core/Mnemosyne.ts
 import Database from "better-sqlite3";
-import { readFileSync as readFileSync4 } from "fs";
 import { resolve as resolve5 } from "path";
 
 // src/core/types.ts
@@ -14324,9 +14336,26 @@ function parseYaml2(text) {
   }
   return root;
 }
+function getVersion2() {
+  try {
+    const { readFileSync: readFileSync7 } = __require("fs");
+    const { resolve: resolve13 } = __require("path");
+    const pkg = JSON.parse(readFileSync7(resolve13(__dirname, "../../package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    try {
+      const { readFileSync: readFileSync7 } = __require("fs");
+      const { resolve: resolve13 } = __require("path");
+      const pkg = JSON.parse(readFileSync7(resolve13(process.cwd(), "package.json"), "utf-8"));
+      return pkg.version;
+    } catch {
+      return "2.0.1";
+    }
+  }
+}
 function defaultConfig2() {
   return {
-    server: { port: 7321, host: "localhost", version: "2.0.0" },
+    server: { port: 7321, host: "localhost", version: getVersion2() },
     database: { path: "data/nexus.db", wal_mode: true, vec_extension_path: "data/vec0" },
     storage: { files_dir: "data/files", max_file_size_mb: 50, backups_dir: "data/backups", backup_interval_hours: 24, max_backups: 7 },
     limits: { max_atoms_per_project: 1e4, rate_limit_requests: 100, rate_limit_window_ms: 6e4 },
@@ -14349,8 +14378,8 @@ function mergeDeep2(target, source) {
   }
   return output;
 }
-function loadConfig2(configPath) {
-  const path = configPath ? resolve4(configPath) : resolve4(process.cwd(), "config.yaml");
+function loadConfig2(configPath, baseDir = process.cwd()) {
+  const path = configPath ? resolve4(configPath) : resolve4(baseDir, "config.yaml");
   if (!existsSync4(path)) {
     if (!configPath) console.warn("[Config] config.yaml not found, using defaults");
     return defaultConfig2();
@@ -14366,23 +14395,237 @@ function loadConfig2(configPath) {
 }
 var MnemosyneConfig = class {
   config;
+  baseDir;
   constructor(options) {
-    this.config = loadConfig2(options?.configPath);
+    this.baseDir = options?.baseDir || process.cwd();
+    this.config = loadConfig2(options?.configPath, this.baseDir);
     if (options?.overrides) {
       this.config = mergeDeep2(this.config, options.overrides);
     }
   }
   get dbPath() {
-    return resolve4(process.cwd(), this.config.database.path);
+    return resolve4(this.baseDir, this.config.database.path);
   }
   get filesDir() {
-    return resolve4(process.cwd(), this.config.storage.files_dir);
+    return resolve4(this.baseDir, this.config.storage.files_dir);
   }
   get backupsDir() {
-    return resolve4(process.cwd(), this.config.storage.backups_dir);
+    return resolve4(this.baseDir, this.config.storage.backups_dir);
+  }
+  get baseDirPath() {
+    return this.baseDir;
   }
 };
 
+// src/db/schema.ts
+var SCHEMA_SQL = `-- Mnemosyne v1.1 Database Schema
+-- SQLite with sqlite-vec extension for semantic search
+
+-- PROJECTS (Spaces)
+CREATE TABLE IF NOT EXISTS projects (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL UNIQUE,
+    description TEXT,
+    icon TEXT DEFAULT '\u25C9',
+    color TEXT DEFAULT '#6366f1',
+    created_at INTEGER DEFAULT (unixepoch()),
+    updated_at INTEGER DEFAULT (unixepoch()),
+    owner TEXT DEFAULT 'human',
+    metadata TEXT DEFAULT '{}'
+);
+
+-- ATOMS (Ideas/Nodes)
+CREATE TABLE IF NOT EXISTS atoms (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+    parent_id TEXT REFERENCES atoms(id) ON DELETE CASCADE,
+    title TEXT NOT NULL,
+    summary TEXT,
+    icon TEXT DEFAULT '\u25CF',
+    color TEXT,
+    x REAL,
+    y REAL,
+    auto_path TEXT,
+    path_overridden INTEGER DEFAULT 0,
+    status TEXT DEFAULT 'draft',
+    status_updated_at INTEGER DEFAULT (unixepoch()),
+    embedding_status TEXT DEFAULT 'pending',
+    embedding_error TEXT,
+    block_count INTEGER DEFAULT 0,
+    bond_count INTEGER DEFAULT 0,
+    template_id TEXT,
+    created_at INTEGER DEFAULT (unixepoch()),
+    updated_at INTEGER DEFAULT (unixepoch()),
+    version INTEGER DEFAULT 1,
+    locked_by TEXT,
+    locked_at INTEGER,
+    locked_reason TEXT,
+    owner TEXT DEFAULT 'human',
+    metadata TEXT DEFAULT '{}'
+);
+
+-- BLOCKS (Content pieces inside atoms)
+CREATE TABLE IF NOT EXISTS blocks (
+    id TEXT PRIMARY KEY,
+    atom_id TEXT NOT NULL REFERENCES atoms(id) ON DELETE CASCADE,
+    type TEXT NOT NULL DEFAULT 'text',
+    content TEXT,
+    order_index INTEGER DEFAULT 0,
+    created_at INTEGER DEFAULT (unixepoch()),
+    updated_at INTEGER DEFAULT (unixepoch()),
+    metadata TEXT DEFAULT '{}'
+);
+
+-- BONDS (Graph connections between atoms)
+CREATE TABLE IF NOT EXISTS bonds (
+    id TEXT PRIMARY KEY,
+    source_id TEXT NOT NULL REFERENCES atoms(id) ON DELETE CASCADE,
+    target_id TEXT NOT NULL REFERENCES atoms(id) ON DELETE CASCADE,
+    label TEXT DEFAULT 'connects',
+    color TEXT,
+    created_at INTEGER DEFAULT (unixepoch()),
+    UNIQUE(source_id, target_id)
+);
+
+-- ATTACHMENTS (Files in CAS)
+CREATE TABLE IF NOT EXISTS attachments (
+    id TEXT PRIMARY KEY,
+    block_id TEXT REFERENCES blocks(id) ON DELETE CASCADE,
+    file_name TEXT NOT NULL,
+    file_hash TEXT NOT NULL,
+    file_size INTEGER,
+    mime_type TEXT,
+    created_at INTEGER DEFAULT (unixepoch()),
+    UNIQUE(file_hash)
+);
+
+-- EVENT LOG (Immutable audit trail)
+CREATE TABLE IF NOT EXISTS event_log (
+    id TEXT PRIMARY KEY,
+    timestamp INTEGER DEFAULT (unixepoch()),
+    event_type TEXT NOT NULL,
+    project_id TEXT,
+    atom_id TEXT,
+    block_id TEXT,
+    bond_id TEXT,
+    actor TEXT NOT NULL DEFAULT 'system',
+    actor_type TEXT DEFAULT 'system',
+    diff TEXT,
+    trigger TEXT,
+    metadata TEXT DEFAULT '{}'
+);
+
+-- ASSISTANTS (AI Agents)
+CREATE TABLE IF NOT EXISTS assistants (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    role TEXT DEFAULT 'worker',
+    permissions TEXT DEFAULT '{"read":["*"],"write":[],"delete":false}',
+    status TEXT DEFAULT 'active',
+    provider TEXT,
+    connected_at INTEGER DEFAULT (unixepoch()),
+    last_seen INTEGER DEFAULT (unixepoch()),
+    metadata TEXT DEFAULT '{}'
+);
+
+-- QUEUE (Agent waitlist for locked atoms)
+CREATE TABLE IF NOT EXISTS queue (
+    id TEXT PRIMARY KEY,
+    atom_id TEXT NOT NULL REFERENCES atoms(id) ON DELETE CASCADE,
+    assistant_id TEXT NOT NULL REFERENCES assistants(id) ON DELETE CASCADE,
+    requested_at INTEGER DEFAULT (unixepoch()),
+    priority INTEGER DEFAULT 5,
+    status TEXT DEFAULT 'waiting',
+    reason TEXT
+);
+
+-- INDICES
+CREATE INDEX IF NOT EXISTS idx_atoms_project ON atoms(project_id);
+CREATE INDEX IF NOT EXISTS idx_atoms_parent ON atoms(parent_id);
+CREATE INDEX IF NOT EXISTS idx_atoms_locked ON atoms(locked_by) WHERE locked_by IS NOT NULL;
+-- idx_atoms_path_project is created by migration after auto_path column is added
+CREATE INDEX IF NOT EXISTS idx_blocks_atom ON blocks(atom_id);
+CREATE INDEX IF NOT EXISTS idx_bonds_source ON bonds(source_id);
+CREATE INDEX IF NOT EXISTS idx_bonds_target ON bonds(target_id);
+CREATE INDEX IF NOT EXISTS idx_event_log_time ON event_log(timestamp);
+CREATE INDEX IF NOT EXISTS idx_event_log_atom ON event_log(atom_id);
+CREATE INDEX IF NOT EXISTS idx_queue_atom ON queue(atom_id);
+CREATE INDEX IF NOT EXISTS idx_attachments_hash ON attachments(file_hash);
+
+-- Auto-update block_count and bond_count triggers
+CREATE TRIGGER IF NOT EXISTS update_block_count_insert AFTER INSERT ON blocks BEGIN
+  UPDATE atoms SET block_count = block_count + 1 WHERE id = NEW.atom_id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS update_block_count_delete AFTER DELETE ON blocks BEGIN
+  UPDATE atoms SET block_count = block_count - 1 WHERE id = OLD.atom_id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS update_bond_count_insert AFTER INSERT ON bonds BEGIN
+  UPDATE atoms SET bond_count = bond_count + 1 WHERE id = NEW.source_id OR id = NEW.target_id;
+END;
+
+CREATE TRIGGER IF NOT EXISTS update_bond_count_delete AFTER DELETE ON bonds BEGIN
+  UPDATE atoms SET bond_count = bond_count - 1 WHERE id = OLD.source_id OR id = OLD.target_id;
+END;
+
+-- FTS5 FULL-TEXT SEARCH
+-- Separate tables to avoid rowid collisions between atoms and blocks
+
+CREATE VIRTUAL TABLE IF NOT EXISTS search_atoms USING fts5(
+    title, summary,
+    content='atoms', content_rowid='rowid'
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS search_blocks USING fts5(
+    content,
+    content='blocks', content_rowid='rowid'
+);
+
+-- Triggers to keep search_atoms in sync
+CREATE TRIGGER IF NOT EXISTS trig_search_atoms_insert AFTER INSERT ON atoms BEGIN
+    INSERT INTO search_atoms(rowid, title, summary) VALUES (new.rowid, new.title, COALESCE(new.summary, ''));
+END;
+
+CREATE TRIGGER IF NOT EXISTS trig_search_atoms_update AFTER UPDATE ON atoms BEGIN
+    UPDATE search_atoms SET title = new.title, summary = COALESCE(new.summary, '') WHERE rowid = new.rowid;
+END;
+
+CREATE TRIGGER IF NOT EXISTS trig_search_atoms_delete AFTER DELETE ON atoms BEGIN
+    DELETE FROM search_atoms WHERE rowid = old.rowid;
+END;
+
+-- Triggers to keep search_blocks in sync
+CREATE TRIGGER IF NOT EXISTS trig_search_blocks_insert AFTER INSERT ON blocks BEGIN
+    INSERT INTO search_blocks(rowid, content) VALUES (new.rowid, COALESCE(new.content, ''));
+END;
+
+CREATE TRIGGER IF NOT EXISTS trig_search_blocks_update AFTER UPDATE ON blocks BEGIN
+    UPDATE search_blocks SET content = COALESCE(new.content, '') WHERE rowid = new.rowid;
+END;
+
+CREATE TRIGGER IF NOT EXISTS trig_search_blocks_delete AFTER DELETE ON blocks BEGIN
+    DELETE FROM search_blocks WHERE rowid = old.rowid;
+END;
+
+
+-- PER-ATOM PERMISSIONS (Granular access control)
+CREATE TABLE IF NOT EXISTS atom_permissions (
+    id TEXT PRIMARY KEY,
+    atom_id TEXT NOT NULL REFERENCES atoms(id) ON DELETE CASCADE,
+    assistant_id TEXT NOT NULL REFERENCES assistants(id) ON DELETE CASCADE,
+    level TEXT NOT NULL DEFAULT 'view',
+    granted_by TEXT,
+    granted_at INTEGER DEFAULT (unixepoch()),
+    metadata TEXT DEFAULT '{}',
+    UNIQUE(atom_id, assistant_id)
+);
+
+-- sqlite-vec virtual table for semantic embeddings
+-- Created dynamically by connection.ts after loading the extension
+-- CREATE VIRTUAL TABLE IF NOT EXISTS atom_vectors USING vec0(atom_id TEXT PRIMARY KEY, embedding float[384]);
+`;
+
 // src/core/Mnemosyne.ts
 var Mnemosyne = class {
   store;
@@ -14390,7 +14633,7 @@ var Mnemosyne = class {
   vecEnabled;
   db;
   constructor(options = {}) {
-    this.config = new MnemosyneConfig({ configPath: options.configPath });
+    this.config = new MnemosyneConfig({ configPath: options.configPath, baseDir: options.baseDir });
     const cfg = this.config.config;
     const dbPath = options.dbPath || this.config.dbPath;
     this.db = new Database(dbPath);
@@ -14399,17 +14642,21 @@ var Mnemosyne = class {
     this.db.pragma("synchronous = NORMAL");
     this.vecEnabled = false;
     try {
-      const vecPath = resolve5(process.cwd(), cfg.database.vec_extension_path);
+      let vecPath;
+      try {
+        const sqliteVec = __require("sqlite-vec");
+        vecPath = sqliteVec.getLoadablePath();
+      } catch {
+        vecPath = resolve5(this.config.baseDirPath || process.cwd(), cfg.database.vec_extension_path);
+      }
       this.db.loadExtension(vecPath);
       this.vecEnabled = true;
       console.log("[DB] sqlite-vec extension loaded");
     } catch (err) {
       console.warn("[DB] sqlite-vec not available:", err.message);
     }
-    const schemaPath = resolve5(process.cwd(), "src", "db", "schema.sql");
     try {
-      const schema = readFileSync4(schemaPath, "utf-8");
-      this.db.exec(schema);
+      this.db.exec(SCHEMA_SQL);
     } catch (err) {
       console.error("[DB] Failed to load schema:", err.message);
     }
@@ -14453,7 +14700,7 @@ var Mnemosyne = class {
 
 // src/server/MnemosyneServer.ts
 import { createServer } from "http";
-import { readFileSync as readFileSync7, existsSync as existsSync6 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync6 } from "fs";
 import { resolve as resolve8 } from "path";
 
 // node_modules/ws/wrapper.mjs
@@ -15608,19 +15855,19 @@ function handleFiles(store, pathname, method, req, res, maxFileSizeMb) {
 // src/server/export-format.ts
 import AdmZip2 from "adm-zip";
 import { createHash as createHash2 } from "crypto";
-import { readFileSync as readFileSync5, existsSync as existsSync5, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync5, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { resolve as resolve6 } from "path";
 var DB_PATH = resolve6(process.cwd(), "data", "nexus.db");
 var FILES_DIR2 = resolve6(process.cwd(), "data", "files");
 function sha256File(path) {
-  return createHash2("sha256").update(readFileSync5(path)).digest("hex");
+  return createHash2("sha256").update(readFileSync4(path)).digest("hex");
 }
 function sha256Dir(dir) {
   const hash = createHash2("sha256");
   function walk(p) {
     const stat = statSync2(p);
     if (stat.isFile()) {
-      hash.update(readFileSync5(p));
+      hash.update(readFileSync4(p));
     } else if (stat.isDirectory()) {
       for (const child of readdirSync2(p).sort()) walk(resolve6(p, child));
     }
@@ -15761,12 +16008,20 @@ function handleEvents(store, pathname, method, res, searchParams) {
 }
 
 // src/api/routes/health.ts
+var PKG_VERSION = (() => {
+  try {
+    const pkg = JSON.parse(__require("fs").readFileSync(__require("path").resolve(__dirname, "../../../package.json"), "utf-8"));
+    return pkg.version;
+  } catch {
+    return "2.0.1";
+  }
+})();
 function handleHealth(store, pathname, method, res) {
-  if (pathname === "/health" && method === "GET") {
+  if ((pathname === "/health" || pathname === "/api/v1/health") && method === "GET") {
     const stats = store.getStats();
     json(res, 200, {
       status: "ok",
-      version: "2.0.0",
+      version: PKG_VERSION,
       storage: "sqlite",
       database: store.config.database.path,
       uptime: process.uptime(),
@@ -15992,7 +16247,6 @@ var WebSocketHandler = class {
 // src/db/connection.ts
 init_config();
 import Database2 from "better-sqlite3";
-import { readFileSync as readFileSync6 } from "fs";
 import { resolve as resolve7 } from "path";
 var DB_PATH2 = process.env.MNEMOSYNE_DB_PATH || resolve7(process.cwd(), CONFIG.database.path);
 var db = null;
@@ -16012,8 +16266,7 @@ function getDb() {
       console.warn("[DB] sqlite-vec not available:", err.message);
       vecEnabled = false;
     }
-    const schema = readFileSync6(resolve7(process.cwd(), "src", "db", "schema.sql"), "utf-8");
-    db.exec(schema);
+    db.exec(SCHEMA_SQL);
     if (vecEnabled) {
       try {
         db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS atom_vectors USING vec0(atom_id TEXT PRIMARY KEY, embedding float[${CONFIG.embeddings.dimension}])`);
@@ -16045,7 +16298,6 @@ var Store2 = class extends Store {
 };
 
 // src/server/MnemosyneServer.ts
-init_config();
 var MnemosyneServer = class {
   store;
   api;
@@ -16053,8 +16305,9 @@ var MnemosyneServer = class {
   httpServer;
   brain;
   constructor(options = {}, brain) {
-    const port = options.port ?? CONFIG.server.port;
-    const host = options.host ?? CONFIG.server.host;
+    const cfg = brain?.config?.config;
+    const port = options.port ?? cfg?.server?.port ?? 7321;
+    const host = options.host ?? cfg?.server?.host ?? "localhost";
     const enableDashboard = options.dashboard !== false;
     const enableWebsocket = options.websocket !== false;
     process.on("uncaughtException", (err) => {
@@ -16082,8 +16335,9 @@ var MnemosyneServer = class {
       const wss = new import_websocket_server.default({ server: this.httpServer });
       this.wsHandler = new WebSocketHandler(wss, this.store);
     }
+    const version = cfg?.server?.version || "2.0.1";
     this.httpServer.listen(port, () => {
-      console.log(`Mnemosyne v${CONFIG.server.version} \u2014 port ${port}`);
+      console.log(`Mnemosyne v${version} \u2014 port ${port}`);
       console.log(`Dashboard: http://${host}:${port}/dashboard`);
       console.log(`API:       http://${host}:${port}/api/v1`);
       console.log(`MCP:       http://${host}:${port}/mcp/manifest`);
@@ -16108,12 +16362,13 @@ var MnemosyneServer = class {
     };
     const dirs = [
       resolve8(process.cwd(), "src/dashboard"),
-      resolve8(process.cwd(), "dashboard")
+      resolve8(process.cwd(), "dashboard"),
+      resolve8(__dirname, "../dashboard")
     ];
     for (const dir of dirs) {
       const filePath = resolve8(dir, urlPath);
       if (existsSync6(filePath)) {
-        const data = readFileSync7(filePath);
+        const data = readFileSync5(filePath);
         res.writeHead(200, { "Content-Type": mime[ext] || "application/octet-stream" });
         res.end(data);
         return;
@@ -16135,7 +16390,7 @@ var MnemosyneServer = class {
 async function startCommand(options) {
   const dataDir = resolve9(options.dataDir);
   const dbPath = resolve9(dataDir, "nexus.db");
-  const brain = new Mnemosyne({ dbPath, configPath: options.config });
+  const brain = new Mnemosyne({ dbPath, configPath: options.config, baseDir: dataDir });
   await brain.init();
   if (options.mcpTransport === "stdio" && options.mcp) {
     if (options.verbose) {
@@ -16225,7 +16480,7 @@ async function initCommand(options) {
   }
   const dbPath = resolve10(dataDir, "nexus.db");
   if (!existsSync7(dbPath)) {
-    const brain = new Mnemosyne({ dbPath, configPath });
+    const brain = new Mnemosyne({ dbPath, configPath, baseDir: dataDir });
     await brain.init();
     await brain.close();
     console.log(`\u2705 Initialized database: ${dbPath}`);
@@ -16239,14 +16494,14 @@ async function initCommand(options) {
 
 // src/cli/commands/migrate.ts
 import { resolve as resolve11 } from "path";
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync6 } from "fs";
 async function migrateCommand(options) {
   const fromPath = resolve11(options.from);
   const toPath = resolve11(options.to);
   console.log(`\u{1F504} Migrating v1.0 JSON \u2192 v2.0 SQLite`);
   console.log(`   From: ${fromPath}`);
   console.log(`   To:   ${toPath}`);
-  const raw = readFileSync8(fromPath, "utf-8");
+  const raw = readFileSync6(fromPath, "utf-8");
   const v1 = JSON.parse(raw);
   const brain = new Mnemosyne({ dbPath: toPath });
   await brain.init();