mnemosyne-core 2.0.0 → 2.0.1

package/dist/{Store-N3j0Vaj6.d.mts → Store-BtdYuiUx.d.mts}

@@ -137,6 +137,24 @@ interface Config {
         default_type: string;
     };
 }
+declare const TEMPLATES: Record<string, {
+    name: string;
+    blocks: {
+        type: string;
+        content: string;
+    }[];
+}>;
+declare const ROLE_PERMISSIONS: Record<AssistantRole, {
+    actions: Action[];
+    pattern: string;
+}>;
+declare const PRIORITY: {
+    readonly IMMEDIATE: 0;
+    readonly HIGH: 1;
+    readonly NORMAL: 2;
+    readonly LOW: 3;
+    readonly SCHEDULED: 4;
+};
 
 /**
  * Mnemosyne Store Engine
@@ -317,4 +335,4 @@ declare class Store extends EventEmitter {
     };
 }
 
-export { type Atom as A, type Config as C, type Project as P, Store as S };
+export { type Assistant as A, type Block as B, type Config as C, type EventLogEntry as E, PRIORITY as P, type QueueEntry as Q, ROLE_PERMISSIONS as R, Store as S, TEMPLATES as T, type Action as a, type AssistantRole as b, type Atom as c, type Bond as d, type PermissionLevel as e, type Project as f };

package/dist/{Store-N3j0Vaj6.d.ts → Store-BtdYuiUx.d.ts}

@@ -137,6 +137,24 @@ interface Config {
         default_type: string;
     };
 }
+declare const TEMPLATES: Record<string, {
+    name: string;
+    blocks: {
+        type: string;
+        content: string;
+    }[];
+}>;
+declare const ROLE_PERMISSIONS: Record<AssistantRole, {
+    actions: Action[];
+    pattern: string;
+}>;
+declare const PRIORITY: {
+    readonly IMMEDIATE: 0;
+    readonly HIGH: 1;
+    readonly NORMAL: 2;
+    readonly LOW: 3;
+    readonly SCHEDULED: 4;
+};
 
 /**
  * Mnemosyne Store Engine
@@ -317,4 +335,4 @@ declare class Store extends EventEmitter {
     };
 }
 
-export { type Atom as A, type Config as C, type Project as P, Store as S };
+export { type Assistant as A, type Block as B, type Config as C, type EventLogEntry as E, PRIORITY as P, type QueueEntry as Q, ROLE_PERMISSIONS as R, Store as S, TEMPLATES as T, type Action as a, type AssistantRole as b, type Atom as c, type Bond as d, type PermissionLevel as e, type Project as f };

package/dist/cli/index.js

@@ -4351,7 +4351,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);
@@ -4376,7 +4376,7 @@ var require_filesystem = __commonJS({
     module2.exports = {
       LDD_PATH,
       SELF_PATH,
-      readFileSync: readFileSync9,
+      readFileSync: readFileSync7,
       readFile
     };
   }
@@ -4425,7 +4425,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;
@@ -4517,7 +4517,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync9(LDD_PATH);
+        const lddContent = readFileSync7(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -4542,7 +4542,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) {
@@ -4606,7 +4606,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];
@@ -13103,7 +13103,6 @@ var import_path9 = require("path");
 
 // src/core/Mnemosyne.ts
 var import_better_sqlite32 = __toESM(require("better-sqlite3"));
-var import_fs5 = require("fs");
 var import_path5 = require("path");
 
 // src/core/types.ts
@@ -14352,8 +14351,8 @@ function mergeDeep2(target, source) {
   }
   return output;
 }
-function loadConfig2(configPath) {
-  const path = configPath ? (0, import_path4.resolve)(configPath) : (0, import_path4.resolve)(process.cwd(), "config.yaml");
+function loadConfig2(configPath, baseDir = process.cwd()) {
+  const path = configPath ? (0, import_path4.resolve)(configPath) : (0, import_path4.resolve)(baseDir, "config.yaml");
   if (!(0, import_fs4.existsSync)(path)) {
     if (!configPath) console.warn("[Config] config.yaml not found, using defaults");
     return defaultConfig2();
@@ -14369,23 +14368,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 (0, import_path4.resolve)(process.cwd(), this.config.database.path);
+    return (0, import_path4.resolve)(this.baseDir, this.config.database.path);
   }
   get filesDir() {
-    return (0, import_path4.resolve)(process.cwd(), this.config.storage.files_dir);
+    return (0, import_path4.resolve)(this.baseDir, this.config.storage.files_dir);
   }
   get backupsDir() {
-    return (0, import_path4.resolve)(process.cwd(), this.config.storage.backups_dir);
+    return (0, import_path4.resolve)(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;
@@ -14393,7 +14606,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 import_better_sqlite32.default(dbPath);
@@ -14402,17 +14615,15 @@ var Mnemosyne = class {
     this.db.pragma("synchronous = NORMAL");
     this.vecEnabled = false;
     try {
-      const vecPath = (0, import_path5.resolve)(process.cwd(), cfg.database.vec_extension_path);
+      const vecPath = (0, import_path5.resolve)(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 = (0, import_path5.resolve)(process.cwd(), "src", "db", "schema.sql");
     try {
-      const schema = (0, import_fs5.readFileSync)(schemaPath, "utf-8");
-      this.db.exec(schema);
+      this.db.exec(SCHEMA_SQL);
     } catch (err) {
       console.error("[DB] Failed to load schema:", err.message);
     }
@@ -14456,7 +14667,7 @@ var Mnemosyne = class {
 
 // src/server/MnemosyneServer.ts
 var import_http = require("http");
-var import_fs8 = require("fs");
+var import_fs6 = require("fs");
 var import_path8 = require("path");
 
 // node_modules/ws/wrapper.mjs
@@ -15611,21 +15822,21 @@ function handleFiles(store, pathname, method, req, res, maxFileSizeMb) {
 // src/server/export-format.ts
 var import_adm_zip2 = __toESM(require("adm-zip"));
 var import_crypto2 = require("crypto");
-var import_fs6 = require("fs");
+var import_fs5 = require("fs");
 var import_path6 = require("path");
 var DB_PATH = (0, import_path6.resolve)(process.cwd(), "data", "nexus.db");
 var FILES_DIR2 = (0, import_path6.resolve)(process.cwd(), "data", "files");
 function sha256File(path) {
-  return (0, import_crypto2.createHash)("sha256").update((0, import_fs6.readFileSync)(path)).digest("hex");
+  return (0, import_crypto2.createHash)("sha256").update((0, import_fs5.readFileSync)(path)).digest("hex");
 }
 function sha256Dir(dir) {
   const hash = (0, import_crypto2.createHash)("sha256");
   function walk(p) {
-    const stat = (0, import_fs6.statSync)(p);
+    const stat = (0, import_fs5.statSync)(p);
     if (stat.isFile()) {
-      hash.update((0, import_fs6.readFileSync)(p));
+      hash.update((0, import_fs5.readFileSync)(p));
     } else if (stat.isDirectory()) {
-      for (const child of (0, import_fs6.readdirSync)(p).sort()) walk((0, import_path6.resolve)(p, child));
+      for (const child of (0, import_fs5.readdirSync)(p).sort()) walk((0, import_path6.resolve)(p, child));
     }
   }
   walk(dir);
@@ -15634,11 +15845,11 @@ function sha256Dir(dir) {
 function buildMnemosyneExport(projectId, projectName) {
   const zip = new import_adm_zip2.default();
   zip.addLocalFile(DB_PATH, "", "nexus.db");
-  if ((0, import_fs6.existsSync)(FILES_DIR2)) {
+  if ((0, import_fs5.existsSync)(FILES_DIR2)) {
     zip.addLocalFolder(FILES_DIR2, "files");
   }
   const dbChecksum = sha256File(DB_PATH);
-  const filesChecksum = (0, import_fs6.existsSync)(FILES_DIR2) ? sha256Dir(FILES_DIR2) : "";
+  const filesChecksum = (0, import_fs5.existsSync)(FILES_DIR2) ? sha256Dir(FILES_DIR2) : "";
   const manifest = {
     version: "1.1",
     app: "Mnemosyne",
@@ -15994,7 +16205,6 @@ var WebSocketHandler = class {
 
 // src/db/connection.ts
 var import_better_sqlite33 = __toESM(require("better-sqlite3"));
-var import_fs7 = require("fs");
 var import_path7 = require("path");
 init_config();
 var DB_PATH2 = process.env.MNEMOSYNE_DB_PATH || (0, import_path7.resolve)(process.cwd(), CONFIG.database.path);
@@ -16015,8 +16225,7 @@ function getDb() {
       console.warn("[DB] sqlite-vec not available:", err.message);
       vecEnabled = false;
     }
-    const schema = (0, import_fs7.readFileSync)((0, import_path7.resolve)(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}])`);
@@ -16115,8 +16324,8 @@ var MnemosyneServer = class {
     ];
     for (const dir of dirs) {
       const filePath = (0, import_path8.resolve)(dir, urlPath);
-      if ((0, import_fs8.existsSync)(filePath)) {
-        const data = (0, import_fs8.readFileSync)(filePath);
+      if ((0, import_fs6.existsSync)(filePath)) {
+        const data = (0, import_fs6.readFileSync)(filePath);
         res.writeHead(200, { "Content-Type": mime[ext] || "application/octet-stream" });
         res.end(data);
         return;
@@ -16138,7 +16347,7 @@ var MnemosyneServer = class {
 async function startCommand(options) {
   const dataDir = (0, import_path9.resolve)(options.dataDir);
   const dbPath = (0, import_path9.resolve)(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) {
@@ -16182,7 +16391,7 @@ ${signal} received. Shutting down...`);
 
 // src/cli/commands/init.ts
 var import_path10 = require("path");
-var import_fs9 = require("fs");
+var import_fs7 = require("fs");
 var DEFAULT_CONFIG = `database:
   path: ./data/nexus.db
   wal: true
@@ -16207,28 +16416,28 @@ server:
 async function initCommand(options) {
   const dataDir = (0, import_path10.resolve)(options.dataDir);
   const configPath = options.config ? (0, import_path10.resolve)(options.config) : (0, import_path10.resolve)(dataDir, "config.yaml");
-  if ((0, import_fs9.existsSync)(dataDir)) {
+  if ((0, import_fs7.existsSync)(dataDir)) {
     console.log(`\u{1F4C1} Data directory already exists: ${dataDir}`);
   } else {
-    (0, import_fs9.mkdirSync)(dataDir, { recursive: true });
+    (0, import_fs7.mkdirSync)(dataDir, { recursive: true });
     console.log(`\u2705 Created data directory: ${dataDir}`);
   }
   for (const sub of ["backups", "files", "exports"]) {
     const dir = (0, import_path10.resolve)(dataDir, sub);
-    if (!(0, import_fs9.existsSync)(dir)) {
-      (0, import_fs9.mkdirSync)(dir, { recursive: true });
+    if (!(0, import_fs7.existsSync)(dir)) {
+      (0, import_fs7.mkdirSync)(dir, { recursive: true });
       console.log(`\u2705 Created ${sub}/`);
     }
   }
-  if (!(0, import_fs9.existsSync)(configPath)) {
-    (0, import_fs9.writeFileSync)(configPath, DEFAULT_CONFIG, "utf-8");
+  if (!(0, import_fs7.existsSync)(configPath)) {
+    (0, import_fs7.writeFileSync)(configPath, DEFAULT_CONFIG, "utf-8");
     console.log(`\u2705 Created config: ${configPath}`);
   } else {
     console.log(`\u{1F4C4} Config already exists: ${configPath}`);
   }
   const dbPath = (0, import_path10.resolve)(dataDir, "nexus.db");
-  if (!(0, import_fs9.existsSync)(dbPath)) {
-    const brain = new Mnemosyne({ dbPath, configPath });
+  if (!(0, import_fs7.existsSync)(dbPath)) {
+    const brain = new Mnemosyne({ dbPath, configPath, baseDir: dataDir });
     await brain.init();
     await brain.close();
     console.log(`\u2705 Initialized database: ${dbPath}`);
@@ -16242,14 +16451,14 @@ async function initCommand(options) {
 
 // src/cli/commands/migrate.ts
 var import_path11 = require("path");
-var import_fs10 = require("fs");
+var import_fs8 = require("fs");
 async function migrateCommand(options) {
   const fromPath = (0, import_path11.resolve)(options.from);
   const toPath = (0, import_path11.resolve)(options.to);
   console.log(`\u{1F504} Migrating v1.0 JSON \u2192 v2.0 SQLite`);
   console.log(`   From: ${fromPath}`);
   console.log(`   To:   ${toPath}`);
-  const raw = (0, import_fs10.readFileSync)(fromPath, "utf-8");
+  const raw = (0, import_fs8.readFileSync)(fromPath, "utf-8");
   const v1 = JSON.parse(raw);
   const brain = new Mnemosyne({ dbPath: toPath });
   await brain.init();
@@ -16300,7 +16509,7 @@ async function migrateCommand(options) {
 
 // src/cli/commands/export.ts
 var import_path12 = require("path");
-var import_fs11 = require("fs");
+var import_fs9 = require("fs");
 async function exportCommand(options) {
   const dataDir = (0, import_path12.resolve)(options.dataDir || "./data");
   const format = options.format || "mnemosyne";
@@ -16316,12 +16525,12 @@ async function exportCommand(options) {
   if (format === "mnemosyne") {
     const buffer = buildMnemosyneExport(project.id, project.name);
     const outPath = output || (0, import_path12.resolve)(`${project.name}.mnemosyne`);
-    (0, import_fs11.writeFileSync)(outPath, buffer);
+    (0, import_fs9.writeFileSync)(outPath, buffer);
     console.log(`\u2705 Exported to ${outPath} (${buffer.length} bytes)`);
   } else if (format === "markdown") {
     const md = exportMarkdown(brain.store, project.id);
     const outPath = output || (0, import_path12.resolve)(`${project.name}.md`);
-    (0, import_fs11.writeFileSync)(outPath, md, "utf-8");
+    (0, import_fs9.writeFileSync)(outPath, md, "utf-8");
     console.log(`\u2705 Exported to ${outPath} (${md.length} chars)`);
   } else {
     console.error(`\u274C Unsupported format: ${format}`);