@cccarv82/freya 2.5.7 → 2.6.0

package/cli/web.js

@@ -8,7 +8,7 @@ const { spawn } = require('child_process');
 const { searchWorkspace } = require('../scripts/lib/search-utils');
 const { searchIndex } = require('../scripts/lib/index-utils');
 const { initWorkspace } = require('./init');
-const { defaultInstance: dl } = require('../scripts/lib/DataLayer');
+const { defaultInstance: dl, ready } = require('../scripts/lib/DataLayer');
 const DataManager = require('../scripts/lib/DataManager');
 
 function readAppVersion() {
@@ -2237,6 +2237,7 @@ function seedDevWorkspace(workspaceDir) {
 }
 
 async function cmdWeb({ port, dir, open, dev }) {
+  await ready;
   const host = '127.0.0.1';
 
   const server = http.createServer(async (req, res) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cccarv82/freya",
-  "version": "2.5.7",
+  "version": "2.6.0",
   "description": "Personal AI Assistant with local-first persistence",
   "scripts": {
     "health": "node scripts/validate-data.js && node scripts/validate-structure.js",
@@ -32,8 +32,7 @@
   "preferGlobal": true,
   "dependencies": {
     "@xenova/transformers": "^2.17.2",
-    "better-sqlite3": "^12.6.2",
     "pdf-lib": "^1.17.1",
-    "sqlite3": "^5.1.7"
+    "sql.js": "^1.12.0"
   }
 }

package/scripts/build-vector-index.js

@@ -1,4 +1,4 @@
-const { defaultInstance: dl } = require('./lib/DataLayer');
+const { defaultInstance: dl, ready } = require('./lib/DataLayer');
 const { defaultEmbedder } = require('./lib/Embedder');
 
 /**
@@ -27,6 +27,7 @@ function chunkText(text, maxChars = 800, overlap = 150) {
 }
 
 async function buildVectorIndex() {
+    await ready;
     console.log('[RAG] Booting Embedding Engine...');
     await defaultEmbedder.init();
     console.log('[RAG] Model ready.');

package/scripts/export-obsidian.js

@@ -11,7 +11,7 @@ function ensureDir(p) {
   fs.mkdirSync(p, { recursive: true });
 }
 
-const { defaultInstance: dl } = require('./lib/DataLayer');
+const { defaultInstance: dl, ready } = require('./lib/DataLayer');
 const DataManager = require('./lib/DataManager');
 
 function slugifyFileName(s) {
@@ -43,7 +43,8 @@ function writeNote(baseDir, relPathNoExt, md) {
   return outPath;
 }
 
-function main() {
+async function main() {
+  await ready;
   const workspaceDir = path.resolve(process.cwd());
 
   const dm = new DataManager(path.join(workspaceDir, 'data'), path.join(workspaceDir, 'logs'));
@@ -140,4 +141,4 @@ function main() {
   process.stdout.write(JSON.stringify({ ok: true, created: created.map((p) => path.relative(workspaceDir, p).replace(/\\/g, '/')) }, null, 2) + '\n');
 }
 
-main();
+main().catch(err => { console.error(err); process.exit(1); });

package/scripts/generate-blockers-report.js

@@ -4,6 +4,7 @@ const path = require('path');
 const { toIsoDate, safeParseToMs, isWithinRange } = require('./lib/date-utils');
 
 const DataManager = require('./lib/DataManager');
+const { ready } = require('./lib/DataLayer');
 const REPORT_DIR = path.join(__dirname, '../docs/reports');
 
 const SEVERITY_ORDER = {
@@ -95,7 +96,8 @@ function ensureReportDir() {
   }
 }
 
-function generateReport() {
+async function generateReport() {
+  await ready;
   const now = new Date();
   const nowMs = now.getTime();
   const reportDate = toIsoDate(now);
@@ -201,4 +203,4 @@ function generateReport() {
   console.log(report);
 }
 
-generateReport();
+generateReport().catch(err => { console.error(err); process.exit(1); });

package/scripts/generate-daily-summary.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 
 const DataManager = require('./lib/DataManager');
+const { ready } = require('./lib/DataLayer');
 
 const DATA_DIR = path.join(__dirname, '../data');
 const LOGS_DIR = path.join(__dirname, '../logs/daily');
@@ -9,7 +10,8 @@ const REPORT_DIR = path.join(__dirname, '../docs/reports');
 
 const dm = new DataManager(DATA_DIR, LOGS_DIR);
 
-function generateDailySummary() {
+async function generateDailySummary() {
+    await ready;
     try {
         const now = new Date();
         const start = new Date(now);

package/scripts/generate-executive-report.js

@@ -11,6 +11,7 @@ const path = require('path');
 
 const { toIsoDate, safeParseToMs } = require('./lib/date-utils');
 const DataManager = require('./lib/DataManager');
+const { ready } = require('./lib/DataLayer');
 
 // --- Configuration ---
 const DATA_DIR = path.join(__dirname, '../data');
@@ -110,7 +111,8 @@ function getCreatedAt(blocker) {
 
 // --- Report Generation ---
 
-function generateReport(period) {
+async function generateReport(period) {
+    await ready;
     const { start, end } = getDateRange(period);
     const dateStr = formatDate(new Date());
 
@@ -245,4 +247,4 @@ if (!['daily', 'weekly'].includes(period)) {
     process.exit(1);
 }
 
-generateReport(period);
+generateReport(period).catch(err => { console.error(err); process.exit(1); });

package/scripts/generate-sm-weekly-report.js

@@ -3,6 +3,7 @@ const path = require('path');
 
 const { toIsoDate, safeParseToMs } = require('./lib/date-utils');
 const DataManager = require('./lib/DataManager');
+const { ready } = require('./lib/DataLayer');
 
 const DATA_DIR = path.join(__dirname, '../data');
 const LOGS_DIR = path.join(__dirname, '../logs/daily');
@@ -36,7 +37,8 @@ function normalizeSeverity(blocker) {
   return value;
 }
 
-function generate() {
+async function generate() {
+  await ready;
   ensureDir(REPORT_DIR);
 
   const now = new Date();
@@ -140,4 +142,4 @@ function generate() {
   console.log(`\nSaved: ${outPath}`);
 }
 
-generate();
+generate().catch(err => { console.error(err); process.exit(1); });

package/scripts/lib/DataLayer.js

@@ -1,7 +1,175 @@
-const Database = require('better-sqlite3');
+/**
+ * DataLayer.js (V2.1 - sql.js powered, no native compilation needed)
+ * 
+ * Drop-in replacement for better-sqlite3 using sql.js (WebAssembly SQLite).
+ * Exposes the same API surface: .prepare().all(), .prepare().get(), .prepare().run(),
+ * .exec(), .pragma(), .transaction(), .close()
+ * 
+ * Auto-persists to disk after every write operation.
+ */
+
 const path = require('path');
 const fs = require('fs');
 
+// ---------------------------------------------------------------------------
+// Compatibility wrapper: makes sql.js look like better-sqlite3
+// ---------------------------------------------------------------------------
+
+class PreparedStatement {
+  constructor(wrapper, sql) {
+    this._wrapper = wrapper;
+    this._sql = sql;
+  }
+
+  /**
+   * Execute and return all matching rows as an array of plain objects.
+   * Mirrors better-sqlite3's stmt.all(...params)
+   */
+  all(...params) {
+    const db = this._wrapper._db;
+    let stmt;
+    try {
+      stmt = db.prepare(this._sql);
+      if (params.length > 0) {
+        stmt.bind(this._flattenParams(params));
+      }
+      const results = [];
+      while (stmt.step()) {
+        results.push(stmt.getAsObject());
+      }
+      return results;
+    } finally {
+      if (stmt) stmt.free();
+    }
+  }
+
+  /**
+   * Execute and return the first matching row, or undefined.
+   * Mirrors better-sqlite3's stmt.get(...params)
+   */
+  get(...params) {
+    const db = this._wrapper._db;
+    let stmt;
+    try {
+      stmt = db.prepare(this._sql);
+      if (params.length > 0) {
+        stmt.bind(this._flattenParams(params));
+      }
+      if (stmt.step()) {
+        return stmt.getAsObject();
+      }
+      return undefined;
+    } finally {
+      if (stmt) stmt.free();
+    }
+  }
+
+  /**
+   * Execute a statement (INSERT/UPDATE/DELETE) and return { changes }.
+   * Mirrors better-sqlite3's stmt.run(...params)
+   */
+  run(...params) {
+    const db = this._wrapper._db;
+    db.run(this._sql, this._flattenParams(params));
+    const changes = db.getRowsModified();
+    this._wrapper._save();
+    return { changes };
+  }
+
+  /**
+   * Flatten params: better-sqlite3 accepts (a, b, c) while sql.js wants [a, b, c].
+   * Also handles the case where a single array is passed (already flat).
+   */
+  _flattenParams(params) {
+    if (params.length === 1 && Array.isArray(params[0])) {
+      return params[0];
+    }
+    return params;
+  }
+}
+
+class SqlJsDatabase {
+  constructor(sqlJsDb, filePath) {
+    this._db = sqlJsDb;
+    this._filePath = filePath;
+    this._saveScheduled = false;
+  }
+
+  /**
+   * Persist the in-memory database to disk.
+   */
+  _save() {
+    if (!this._filePath) return;
+    try {
+      const data = this._db.export();
+      const buffer = Buffer.from(data);
+      fs.writeFileSync(this._filePath, buffer);
+    } catch (err) {
+      console.error('[DataLayer] Failed to save database:', err.message);
+    }
+  }
+
+  /**
+   * PRAGMA support. sql.js supports PRAGMA through exec.
+   */
+  pragma(str) {
+    try {
+      this._db.run(`PRAGMA ${str}`);
+    } catch {
+      // Some pragmas may not be supported in WASM mode (e.g., WAL), silently ignore.
+    }
+  }
+
+  /**
+   * Execute raw SQL (typically DDL).
+   * Mirrors better-sqlite3's db.exec(sql)
+   */
+  exec(sql) {
+    this._db.run(sql);
+    this._save();
+  }
+
+  /**
+   * Create a prepared statement wrapper.
+   * Mirrors better-sqlite3's db.prepare(sql)
+   */
+  prepare(sql) {
+    return new PreparedStatement(this, sql);
+  }
+
+  /**
+   * Transaction wrapper. Returns a function that, when called, wraps fn() in BEGIN/COMMIT.
+   * Mirrors better-sqlite3's db.transaction(fn)
+   */
+  transaction(fn) {
+    const self = this;
+    return function (...args) {
+      self._db.run('BEGIN TRANSACTION');
+      try {
+        const result = fn(...args);
+        self._db.run('COMMIT');
+        self._save();
+        return result;
+      } catch (e) {
+        try { self._db.run('ROLLBACK'); } catch { /* already rolled back */ }
+        throw e;
+      }
+    };
+  }
+
+  /**
+   * Close the database.
+   */
+  close() {
+    this._save();
+    this._db.close();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// DataLayer class
+// ---------------------------------------------------------------------------
+
 class DataLayer {
   constructor(dbPath = null) {
     if (!dbPath) {
@@ -11,12 +179,34 @@ class DataLayer {
       }
       dbPath = path.join(dataDir, 'freya.sqlite');
     }
-    this.db = new Database(dbPath);
-    this.initSchema();
+    this._dbPath = dbPath;
+    this.db = null; // Will be set after async init
+  }
+
+  /**
+   * Async initialization (required by sql.js WASM loading).
+   */
+  async init() {
+    if (this.db) return; // Already initialized
+
+    const initSqlJs = require('sql.js');
+    const SQL = await initSqlJs();
+
+    // Load existing database from disk, or create new one
+    let sqlJsDb;
+    if (fs.existsSync(this._dbPath)) {
+      const fileBuffer = fs.readFileSync(this._dbPath);
+      sqlJsDb = new SQL.Database(fileBuffer);
+    } else {
+      sqlJsDb = new SQL.Database();
+    }
+
+    this.db = new SqlJsDatabase(sqlJsDb, this._dbPath);
+    this._initSchema();
   }
 
-  initSchema() {
-    // Enable Write-Ahead Logging for better concurrent performance
+  _initSchema() {
+    // WAL mode may not work in WASM — we try, but it's silently ignored if unsupported
     this.db.pragma('journal_mode = WAL');
 
     this.db.exec(`
@@ -83,10 +273,21 @@ class DataLayer {
 
   // Helper close method
   close() {
-    this.db.close();
+    if (this.db) this.db.close();
   }
 }
 
-// Export a singleton instance by default, or the class for testing
+// ---------------------------------------------------------------------------
+// Singleton + ready promise
+// ---------------------------------------------------------------------------
+
 const defaultInstance = new DataLayer();
-module.exports = { defaultInstance, DataLayer };
+
+// `ready` is a promise that resolves once sql.js is loaded and the DB is ready.
+// All consumers must `await ready` before using `defaultInstance.db`.
+const ready = defaultInstance.init().catch(err => {
+  console.error('[DataLayer] Fatal: Failed to initialize database:', err.message);
+  process.exit(1);
+});
+
+module.exports = { defaultInstance, DataLayer, ready };

package/scripts/lib/Embedder.js

@@ -1,5 +1,3 @@
-const { pipeline } = require('@xenova/transformers');
-
 class Embedder {
     constructor() {
         this.modelName = 'Xenova/all-MiniLM-L6-v2';
@@ -10,14 +8,13 @@ class Embedder {
     async init() {
         if (this.extractorInfo) return;
         if (!this.initPromise) {
-            this.initPromise = pipeline('feature-extraction', this.modelName, { quantized: true })
-                .then((ex) => {
-                    this.extractorInfo = ex;
-                })
-                .catch((err) => {
-                    this.initPromise = null;
-                    throw err;
-                });
+            this.initPromise = (async () => {
+                const { pipeline } = await import('@xenova/transformers');
+                this.extractorInfo = await pipeline('feature-extraction', this.modelName, { quantized: true });
+            })().catch((err) => {
+                this.initPromise = null;
+                throw err;
+            });
         }
         await this.initPromise;
     }

package/scripts/migrate-v1-v2.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const { defaultInstance: dl } = require('./lib/DataLayer');
+const { defaultInstance: dl, ready } = require('./lib/DataLayer');
 const DataManager = require('./lib/DataManager');
 
 const dataDir = path.join(__dirname, '..', 'data');
@@ -173,12 +173,17 @@ function migrateLogs() {
 }
 
 // Transaction wrapper
-dl.db.transaction(() => {
-    migrateProjects();
-    migrateTasks();
-    migrateBlockers();
-    migrateLogs();
-})();
-
-console.log('--- Migração concluída com sucesso! ---');
-dl.close();
+async function main() {
+    await ready;
+    dl.db.transaction(() => {
+        migrateProjects();
+        migrateTasks();
+        migrateBlockers();
+        migrateLogs();
+    })();
+
+    console.log('--- Migração concluída com sucesso! ---');
+    dl.close();
+}
+
+main().catch(err => { console.error(err); process.exit(1); });

package/scripts/validate-structure.js

@@ -7,7 +7,7 @@ const DATA_DIR = path.join(ROOT, 'data');
 const DOCS_DIR = path.join(ROOT, 'docs');
 const CLIENTS_DIR = path.join(DATA_DIR, 'Clients');
 
-const { defaultInstance: dl } = require('./lib/DataLayer');
+const { defaultInstance: dl, ready } = require('./lib/DataLayer');
 const errors = [];
 
 function exists(p) {
@@ -88,7 +88,8 @@ function validateDocsHubs() {
   }
 }
 
-function main() {
+async function main() {
+  await ready;
   // validateDailyLogs(); removed context since migrated to SQLite
   validateProjectStatusHistory();
   validateTaskProjectSlugs();
@@ -102,4 +103,4 @@ function main() {
   console.log('✅ Structure validation passed');
 }
 
-main();
+main().catch(err => { console.error(err); process.exit(1); });

package/templates/base/scripts/lib/DataLayer.js

@@ -1,7 +1,175 @@
-const Database = require('better-sqlite3');
+/**
+ * DataLayer.js (V2.1 - sql.js powered, no native compilation needed)
+ * 
+ * Drop-in replacement for better-sqlite3 using sql.js (WebAssembly SQLite).
+ * Exposes the same API surface: .prepare().all(), .prepare().get(), .prepare().run(),
+ * .exec(), .pragma(), .transaction(), .close()
+ * 
+ * Auto-persists to disk after every write operation.
+ */
+
 const path = require('path');
 const fs = require('fs');
 
+// ---------------------------------------------------------------------------
+// Compatibility wrapper: makes sql.js look like better-sqlite3
+// ---------------------------------------------------------------------------
+
+class PreparedStatement {
+  constructor(wrapper, sql) {
+    this._wrapper = wrapper;
+    this._sql = sql;
+  }
+
+  /**
+   * Execute and return all matching rows as an array of plain objects.
+   * Mirrors better-sqlite3's stmt.all(...params)
+   */
+  all(...params) {
+    const db = this._wrapper._db;
+    let stmt;
+    try {
+      stmt = db.prepare(this._sql);
+      if (params.length > 0) {
+        stmt.bind(this._flattenParams(params));
+      }
+      const results = [];
+      while (stmt.step()) {
+        results.push(stmt.getAsObject());
+      }
+      return results;
+    } finally {
+      if (stmt) stmt.free();
+    }
+  }
+
+  /**
+   * Execute and return the first matching row, or undefined.
+   * Mirrors better-sqlite3's stmt.get(...params)
+   */
+  get(...params) {
+    const db = this._wrapper._db;
+    let stmt;
+    try {
+      stmt = db.prepare(this._sql);
+      if (params.length > 0) {
+        stmt.bind(this._flattenParams(params));
+      }
+      if (stmt.step()) {
+        return stmt.getAsObject();
+      }
+      return undefined;
+    } finally {
+      if (stmt) stmt.free();
+    }
+  }
+
+  /**
+   * Execute a statement (INSERT/UPDATE/DELETE) and return { changes }.
+   * Mirrors better-sqlite3's stmt.run(...params)
+   */
+  run(...params) {
+    const db = this._wrapper._db;
+    db.run(this._sql, this._flattenParams(params));
+    const changes = db.getRowsModified();
+    this._wrapper._save();
+    return { changes };
+  }
+
+  /**
+   * Flatten params: better-sqlite3 accepts (a, b, c) while sql.js wants [a, b, c].
+   * Also handles the case where a single array is passed (already flat).
+   */
+  _flattenParams(params) {
+    if (params.length === 1 && Array.isArray(params[0])) {
+      return params[0];
+    }
+    return params;
+  }
+}
+
+class SqlJsDatabase {
+  constructor(sqlJsDb, filePath) {
+    this._db = sqlJsDb;
+    this._filePath = filePath;
+    this._saveScheduled = false;
+  }
+
+  /**
+   * Persist the in-memory database to disk.
+   */
+  _save() {
+    if (!this._filePath) return;
+    try {
+      const data = this._db.export();
+      const buffer = Buffer.from(data);
+      fs.writeFileSync(this._filePath, buffer);
+    } catch (err) {
+      console.error('[DataLayer] Failed to save database:', err.message);
+    }
+  }
+
+  /**
+   * PRAGMA support. sql.js supports PRAGMA through exec.
+   */
+  pragma(str) {
+    try {
+      this._db.run(`PRAGMA ${str}`);
+    } catch {
+      // Some pragmas may not be supported in WASM mode (e.g., WAL), silently ignore.
+    }
+  }
+
+  /**
+   * Execute raw SQL (typically DDL).
+   * Mirrors better-sqlite3's db.exec(sql)
+   */
+  exec(sql) {
+    this._db.run(sql);
+    this._save();
+  }
+
+  /**
+   * Create a prepared statement wrapper.
+   * Mirrors better-sqlite3's db.prepare(sql)
+   */
+  prepare(sql) {
+    return new PreparedStatement(this, sql);
+  }
+
+  /**
+   * Transaction wrapper. Returns a function that, when called, wraps fn() in BEGIN/COMMIT.
+   * Mirrors better-sqlite3's db.transaction(fn)
+   */
+  transaction(fn) {
+    const self = this;
+    return function (...args) {
+      self._db.run('BEGIN TRANSACTION');
+      try {
+        const result = fn(...args);
+        self._db.run('COMMIT');
+        self._save();
+        return result;
+      } catch (e) {
+        try { self._db.run('ROLLBACK'); } catch { /* already rolled back */ }
+        throw e;
+      }
+    };
+  }
+
+  /**
+   * Close the database.
+   */
+  close() {
+    this._save();
+    this._db.close();
+  }
+}
+
+// ---------------------------------------------------------------------------
+// DataLayer class
+// ---------------------------------------------------------------------------
+
 class DataLayer {
   constructor(dbPath = null) {
     if (!dbPath) {
@@ -11,12 +179,34 @@ class DataLayer {
       }
       dbPath = path.join(dataDir, 'freya.sqlite');
     }
-    this.db = new Database(dbPath);
-    this.initSchema();
+    this._dbPath = dbPath;
+    this.db = null; // Will be set after async init
+  }
+
+  /**
+   * Async initialization (required by sql.js WASM loading).
+   */
+  async init() {
+    if (this.db) return; // Already initialized
+
+    const initSqlJs = require('sql.js');
+    const SQL = await initSqlJs();
+
+    // Load existing database from disk, or create new one
+    let sqlJsDb;
+    if (fs.existsSync(this._dbPath)) {
+      const fileBuffer = fs.readFileSync(this._dbPath);
+      sqlJsDb = new SQL.Database(fileBuffer);
+    } else {
+      sqlJsDb = new SQL.Database();
+    }
+
+    this.db = new SqlJsDatabase(sqlJsDb, this._dbPath);
+    this._initSchema();
   }
 
-  initSchema() {
-    // Enable Write-Ahead Logging for better concurrent performance
+  _initSchema() {
+    // WAL mode may not work in WASM — we try, but it's silently ignored if unsupported
     this.db.pragma('journal_mode = WAL');
 
     this.db.exec(`
@@ -83,10 +273,21 @@ class DataLayer {
 
   // Helper close method
   close() {
-    this.db.close();
+    if (this.db) this.db.close();
   }
 }
 
-// Export a singleton instance by default, or the class for testing
+// ---------------------------------------------------------------------------
+// Singleton + ready promise
+// ---------------------------------------------------------------------------
+
 const defaultInstance = new DataLayer();
-module.exports = { defaultInstance, DataLayer };
+
+// `ready` is a promise that resolves once sql.js is loaded and the DB is ready.
+// All consumers must `await ready` before using `defaultInstance.db`.
+const ready = defaultInstance.init().catch(err => {
+  console.error('[DataLayer] Fatal: Failed to initialize database:', err.message);
+  process.exit(1);
+});
+
+module.exports = { defaultInstance, DataLayer, ready };

package/templates/base/scripts/lib/Embedder.js

@@ -1,5 +1,3 @@
-const { pipeline } = require('@xenova/transformers');
-
 class Embedder {
     constructor() {
         this.modelName = 'Xenova/all-MiniLM-L6-v2';
@@ -10,14 +8,13 @@ class Embedder {
     async init() {
         if (this.extractorInfo) return;
         if (!this.initPromise) {
-            this.initPromise = pipeline('feature-extraction', this.modelName, { quantized: true })
-                .then((ex) => {
-                    this.extractorInfo = ex;
-                })
-                .catch((err) => {
-                    this.initPromise = null;
-                    throw err;
-                });
+            this.initPromise = (async () => {
+                const { pipeline } = await import('@xenova/transformers');
+                this.extractorInfo = await pipeline('feature-extraction', this.modelName, { quantized: true });
+            })().catch((err) => {
+                this.initPromise = null;
+                throw err;
+            });
         }
         await this.initPromise;
     }