moflo 4.9.36 → 4.10.0

package/dist/src/cli/memory/database-provider.js

@@ -1,16 +1,16 @@
 /**
- * DatabaseProvider - Platform-aware database selection
+ * DatabaseProvider — moflo's IMemoryBackend factory.
  *
- * Automatically selects best backend:
- * - All platforms: sql.js (WASM, no native deps)
- * - Windows: sql.js (WASM, universal) when native fails
- * - Fallback: JSON file storage
+ * Phase 5 (#1084) removed the sql.js backend. Selection now collapses to:
+ * - `node-sqlite` (Node 22+ built-in, the only SQLite backend)
+ * - `rvf` (pure-TS fallback when node:sqlite is somehow unavailable)
+ * - `json` (last-resort file storage when nothing else works)
  *
  * @module v3/memory/database-provider
  */
 import { platform } from 'node:os';
 import { existsSync } from 'node:fs';
-import { SqlJsBackend } from './sqljs-backend.js';
+import { SqliteBackend } from './sqlite-backend.js';
 /**
  * Detect platform and recommend provider
  */
@@ -19,8 +19,9 @@ function detectPlatform() {
     const isWindows = os === 'win32';
     const isMacOS = os === 'darwin';
     const isLinux = os === 'linux';
-    // Recommend better-sqlite3 for Unix-like systems, sql.js for Windows
-    const recommendedProvider = 'sql.js';
+    // Phase 4 (#1083) flipped the default to node:sqlite (built into Node 22+,
+    // moflo's minimum). Phase 5 (#1084) deletes the sql.js backend + dep.
+    const recommendedProvider = 'node-sqlite';
     return {
         os,
         isWindows,
@@ -35,55 +36,60 @@ function detectPlatform() {
 async function testRvf() {
     return true;
 }
-/** better-sqlite3 removed — sql.js is the only SQLite backend */
 /**
- * Test if sql.js is available and working
+ * Test if the built-in node:sqlite engine is available (Node 22+).
+ *
+ * Loads the suppress-sqlite-warning side-effect BEFORE the probe import so
+ * the once-per-process ExperimentalWarning never fires (#1098). A probe
+ * that prints the warning to stderr defeats every consumer's "clean
+ * startup" expectation even when the rest of the run is healthy.
  */
-async function testSqlJs() {
+async function testNodeSqlite() {
     try {
-        const { initSqlJsForNode } = await import('./sqljs-backend.js');
-        const SQL = await initSqlJsForNode();
-        const testDb = new SQL.Database();
-        testDb.close();
+        await import('./suppress-sqlite-warning.js');
+        await import('node:sqlite');
         return true;
     }
-    catch (error) {
+    catch {
         return false;
     }
 }
 /**
- * Select best available provider
+ * Select best available provider.
+ *
+ * Phase 5 (#1084) collapsed the chain — sql.js is gone, so the order is
+ * just: explicit override → node:sqlite → RVF → JSON. Passing `'sql.js'`
+ * explicitly is a hard error.
  */
 async function selectProvider(preferred, verbose = false) {
+    if (preferred === 'sql.js') {
+        throw new Error(`DatabaseProvider: sql.js was removed in Phase 5 (#1084). ` +
+            `Use 'node-sqlite' (the new default) or omit the provider entirely.`);
+    }
     if (preferred && preferred !== 'auto') {
         if (verbose) {
             console.log(`[DatabaseProvider] Using explicitly specified provider: ${preferred}`);
         }
         return preferred;
     }
-    const platformInfo = detectPlatform();
+    if (await testNodeSqlite()) {
+        if (verbose) {
+            console.log('[DatabaseProvider] node:sqlite available — using new default');
+        }
+        return 'node-sqlite';
+    }
+    // node:sqlite missing is the "broken install" signal — surface it whenever
+    // verbose is on so the fallback chain doesn't silently regress consumers
+    // to a slower backend without anyone noticing.
     if (verbose) {
-        console.log(`[DatabaseProvider] Platform detected: ${platformInfo.os}`);
-        console.log(`[DatabaseProvider] Recommended provider: ${platformInfo.recommendedProvider}`);
+        console.warn('[DatabaseProvider] node:sqlite unavailable — check Node version (22+ required); falling back to RVF');
     }
-    // Try RVF first (always available via pure-TS fallback)
     if (await testRvf()) {
-        if (verbose) {
-            console.log('[DatabaseProvider] RVF backend available');
-        }
         return 'rvf';
     }
-    // Try sql.js (moflo: sql.js is the only SQLite backend)
-    if (await testSqlJs()) {
-        if (verbose) {
-            console.log('[DatabaseProvider] sql.js available and working');
-        }
-        return 'sql.js';
-    }
-    else if (verbose) {
-        console.log('[DatabaseProvider] sql.js not available, using JSON fallback');
+    if (verbose) {
+        console.warn('[DatabaseProvider] node:sqlite + RVF unavailable — falling back to JSON');
     }
-    // Final fallback to JSON
     return 'json';
 }
 /**
@@ -112,7 +118,7 @@ async function selectProvider(preferred, verbose = false) {
  * ```
  */
 export async function createDatabase(path, options = {}) {
-    const { provider = 'auto', verbose = false, walMode = true, optimize = true, defaultNamespace = 'default', maxEntries = 1000000, autoPersistInterval = 5000, wasmPath, } = options;
+    const { provider = 'auto', verbose = false, walMode: _walMode = true, optimize = true, defaultNamespace = 'default', maxEntries = 1000000, autoPersistInterval = 5000, wasmPath: _wasmPath, } = options;
     // Select provider
     const selectedProvider = await selectProvider(provider, verbose);
     if (verbose) {
@@ -122,6 +128,13 @@ export async function createDatabase(path, options = {}) {
     let backend;
     switch (selectedProvider) {
         case 'sql.js': {
+            // selectProvider() guards against 'sql.js' as an explicit preference,
+            // but a stale caller could still land here if `auto` resolution drifted
+            // (it can't — left only for exhaustive-check safety).
+            throw new Error(`DatabaseProvider: sql.js was removed in Phase 5 (#1084). ` +
+                `This case is unreachable; if you see this error, file a bug.`);
+        }
+        case 'node-sqlite': {
             const config = {
                 databasePath: path,
                 optimize,
@@ -129,9 +142,8 @@ export async function createDatabase(path, options = {}) {
                 maxEntries,
                 verbose,
                 autoPersistInterval,
-                wasmPath,
             };
-            backend = new SqlJsBackend(config);
+            backend = new SqliteBackend(config);
             break;
         }
         case 'rvf': {
@@ -167,13 +179,18 @@ export function getPlatformInfo() {
     return detectPlatform();
 }
 /**
- * Check which providers are available
+ * Check which providers are available.
+ *
+ * `sqlJs` / `betterSqlite3` are retained for API stability but always
+ * report `false` — Phase 5 (#1084) deleted the sql.js backend and
+ * better-sqlite3 was never wired.
  */
 export async function getAvailableProviders() {
     return {
         rvf: true,
-        betterSqlite3: false, // Removed — sql.js is the only SQLite backend
-        sqlJs: await testSqlJs(),
+        betterSqlite3: false,
+        sqlJs: false,
+        nodeSqlite: await testNodeSqlite(),
         json: true,
     };
 }

package/dist/src/cli/memory/hnsw-persistence.js

@@ -16,11 +16,11 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { mofloImport } from '../services/moflo-require.js';
 import { atomicWriteFileSync } from '../services/atomic-file-write.js';
 import { HnswLite } from './hnsw-lite.js';
 import { parseEmbeddingJson } from './controllers/_shared.js';
 import { hnswIndexPath } from '../services/moflo-paths.js';
+import { openDaemonDatabase } from './daemon-backend.js';
 /**
  * Build an HnswLite from every active row in `dbPath` that has an embedding,
  * then atomically write the sidecar to `<projectRoot>/.moflo/hnsw.index`.
@@ -37,13 +37,11 @@ export async function buildAndWriteHnswSidecar(dbPath, projectRoot, options = {}
     if (!fs.existsSync(dbPath)) {
         throw new Error(`buildAndWriteHnswSidecar: db not found at ${dbPath}`);
     }
-    const sqlJsModule = await mofloImport('sql.js');
-    if (!sqlJsModule) {
-        throw new Error(`buildAndWriteHnswSidecar: sql.js not available`);
-    }
-    const SQL = await sqlJsModule.default();
-    const buf = fs.readFileSync(dbPath);
-    const db = new SQL.Database(buf);
+    // node:sqlite via the unified factory — Phase 5 (#1084) replaced the
+    // sql.js readFileSync + new SQL.Database round-trip with a direct open
+    // through openDaemonDatabase. WAL writes incrementally so there's nothing
+    // to flush back here; the sidecar persistence below is unaffected.
+    const db = openDaemonDatabase(dbPath);
     const hnsw = new HnswLite(dimensions, m, efConstruction, metric);
     let skipped = 0;
     try {

package/dist/src/cli/memory/index.js

@@ -61,7 +61,6 @@ export { ControllerRegistry, INIT_LEVELS } from './controller-registry.js';
 export { CONTROLLER_SPECS } from './controller-specs.js';
 // ===== Core Components =====
 export { MofloDbAdapter } from './moflo-db-adapter.js';
-export { SqlJsBackend } from './sqljs-backend.js';
 export { RvfBackend } from './rvf-backend.js';
 export { HnswLite, cosineSimilarity } from './hnsw-lite.js';
 export { buildAndWriteHnswSidecar, tryLoadHnswSidecar } from './hnsw-persistence.js';

package/dist/src/cli/memory/memory-bridge.js

@@ -119,17 +119,49 @@ export async function bridgeAddToHNSW(id, embedding, entry, dbPath) {
         // Bridge-produced vectors come from getBridgeEmbedder() (fastembed, 384-dim).
         // Pre-#648 this column was hardcoded to 'Xenova/all-MiniLM-L6-v2' which
         // misrepresented the producing model — fixed to the canonical bridge label.
-        ctx.db.prepare(`
-      INSERT OR REPLACE INTO memory_entries (
-        id, key, namespace, content, type,
-        embedding, embedding_dimensions, embedding_model,
-        created_at, updated_at, status
-      ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, 'active')
+        //
+        // Pre-#1067: this issued `INSERT OR REPLACE INTO memory_entries (...)` with
+        // only the embedding-related columns. When `storeEntry`'s direct-write
+        // fallback first inserted a row carrying `metadata`/`tags`/`expires_at`
+        // and then called `addToHNSWIndex(...)` for the same id, REPLACE clobbered
+        // the row — wiping the metadata column to NULL and re-introducing the
+        // "first chunk has no navigation" smoke failure even though serialiseMetadata
+        // produced the right JSON one statement earlier. UPDATE-by-id preserves the
+        // pre-existing row's metadata/tags/expires_at/access_count while still
+        // back-filling embedding columns for callers that supplied them.
+        const updated = ctx.db.prepare(`
+      UPDATE memory_entries
+         SET embedding = ?,
+             embedding_dimensions = ?,
+             embedding_model = ?,
+             updated_at = ?
+       WHERE id = ?
     `).run([
-            id, entry.key, entry.namespace, entry.content,
             embeddingJson, embedding.length, BRIDGE_EMBEDDING_MODEL,
-            now, now,
+            now, id,
         ]);
+        // If no row was matched by id (rare: a rebuild path passing an embedding
+        // for a key that never went through storeEntry first) fall back to an
+        // INSERT carrying every column the bridge can populate, so the row still
+        // becomes searchable. Metadata/tags/expires_at stay NULL because the
+        // caller didn't supply them — same shape `bridgeStoreEntry` would write
+        // for a no-metadata caller.
+        const rowCount = typeof updated.changes === 'number'
+            ? updated.changes
+            : (ctx.db.getRowsModified?.() ?? 0);
+        if (rowCount === 0) {
+            ctx.db.prepare(`
+        INSERT INTO memory_entries (
+          id, key, namespace, content, type,
+          embedding, embedding_dimensions, embedding_model,
+          created_at, updated_at, status
+        ) VALUES (?, ?, ?, ?, 'semantic', ?, ?, ?, ?, ?, 'active')
+      `).run([
+                id, entry.key, entry.namespace, entry.content,
+                embeddingJson, embedding.length, BRIDGE_EMBEDDING_MODEL,
+                now, now,
+            ]);
+        }
         persistBridgeDb(ctx.db, dbPath);
         return true;
     });