agentic-flow 2.0.7 → 3.0.0-alpha.2

package/dist/intelligence/IntelligenceStore.js

@@ -1,29 +1,208 @@
 /**
  * IntelligenceStore - SQLite persistence for RuVector intelligence layer
  *
- * Cross-platform (Linux, macOS, Windows) persistent storage for:
- * - Learning trajectories
- * - Routing patterns
- * - SONA adaptations
- * - HNSW vectors
+ * Uses sql.js (pure JS SQLite) as primary backend for cross-platform compatibility
+ * Falls back to better-sqlite3 only if sql.js fails
  */
-import Database from 'better-sqlite3';
-import { existsSync, mkdirSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { dirname, join } from 'path';
 import { homedir } from 'os';
-export class IntelligenceStore {
+// sql.js wrapper
+class SqlJsWrapper {
     db;
+    dbPath;
+    saveTimeout = null;
+    constructor(db, dbPath) {
+        this.db = db;
+        this.dbPath = dbPath;
+    }
+    scheduleSave() {
+        if (this.saveTimeout) {
+            clearTimeout(this.saveTimeout);
+        }
+        this.saveTimeout = setTimeout(() => {
+            this.saveNow();
+        }, 100); // Debounce saves
+    }
+    saveNow() {
+        try {
+            const data = this.db.export();
+            const buffer = Buffer.from(data);
+            writeFileSync(this.dbPath, buffer);
+        }
+        catch {
+            // Ignore save errors
+        }
+    }
+    run(sql, params) {
+        this.db.run(sql, params || []);
+        const lastId = this.db.exec('SELECT last_insert_rowid() as id')[0]?.values[0]?.[0] || 0;
+        const changes = this.db.getRowsModified();
+        this.scheduleSave();
+        return { lastInsertRowid: lastId, changes };
+    }
+    get(sql, params) {
+        const stmt = this.db.prepare(sql);
+        if (params)
+            stmt.bind(params);
+        if (stmt.step()) {
+            const columns = stmt.getColumnNames();
+            const values = stmt.get();
+            stmt.free();
+            const result = {};
+            columns.forEach((col, i) => {
+                result[col] = values[i];
+            });
+            return result;
+        }
+        stmt.free();
+        return undefined;
+    }
+    all(sql, params) {
+        const results = [];
+        const stmt = this.db.prepare(sql);
+        if (params)
+            stmt.bind(params);
+        while (stmt.step()) {
+            const columns = stmt.getColumnNames();
+            const values = stmt.get();
+            const row = {};
+            columns.forEach((col, i) => {
+                row[col] = values[i];
+            });
+            results.push(row);
+        }
+        stmt.free();
+        return results;
+    }
+    exec(sql) {
+        this.db.exec(sql);
+        this.scheduleSave();
+    }
+    close() {
+        if (this.saveTimeout) {
+            clearTimeout(this.saveTimeout);
+        }
+        this.saveNow();
+        this.db.close();
+    }
+}
+// better-sqlite3 wrapper
+class BetterSqliteWrapper {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    run(sql, params) {
+        const stmt = this.db.prepare(sql);
+        const result = params ? stmt.run(...params) : stmt.run();
+        return { lastInsertRowid: result.lastInsertRowid, changes: result.changes };
+    }
+    get(sql, params) {
+        const stmt = this.db.prepare(sql);
+        return params ? stmt.get(...params) : stmt.get();
+    }
+    all(sql, params) {
+        const stmt = this.db.prepare(sql);
+        return params ? stmt.all(...params) : stmt.all();
+    }
+    exec(sql) {
+        this.db.exec(sql);
+    }
+    close() {
+        this.db.close();
+    }
+}
+export class IntelligenceStore {
+    db = null;
+    dbPath;
+    initialized = false;
+    initPromise = null;
     static instance = null;
     constructor(dbPath) {
+        this.dbPath = dbPath;
+    }
+    /**
+     * Initialize the database (async to support sql.js)
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = this.doInitialize();
+        await this.initPromise;
+    }
+    async doInitialize() {
         // Ensure directory exists
-        const dir = dirname(dbPath);
+        const dir = dirname(this.dbPath);
         if (!existsSync(dir)) {
             mkdirSync(dir, { recursive: true });
         }
-        this.db = new Database(dbPath);
-        this.db.pragma('journal_mode = WAL'); // Better concurrent access
-        this.db.pragma('synchronous = NORMAL'); // Good balance of speed/safety
-        this.initSchema();
+        // Try sql.js first (pure JS, no native modules)
+        try {
+            const initSqlJs = (await import('sql.js')).default;
+            const SQL = await initSqlJs();
+            let db;
+            if (existsSync(this.dbPath)) {
+                const fileBuffer = readFileSync(this.dbPath);
+                db = new SQL.Database(fileBuffer);
+            }
+            else {
+                db = new SQL.Database();
+            }
+            this.db = new SqlJsWrapper(db, this.dbPath);
+            this.initialized = true;
+            this.initSchema();
+            return;
+        }
+        catch (e) {
+            // sql.js failed, try better-sqlite3
+        }
+        // Try better-sqlite3 as fallback
+        try {
+            const Database = (await import('better-sqlite3')).default;
+            const db = new Database(this.dbPath);
+            db.pragma('journal_mode = WAL');
+            db.pragma('synchronous = NORMAL');
+            this.db = new BetterSqliteWrapper(db);
+            this.initialized = true;
+            this.initSchema();
+            return;
+        }
+        catch (e) {
+            // Both failed, use in-memory fallback
+        }
+        // Last resort: in-memory sql.js (won't persist but won't crash)
+        try {
+            const initSqlJs = (await import('sql.js')).default;
+            const SQL = await initSqlJs();
+            const db = new SQL.Database();
+            this.db = new SqlJsWrapper(db, this.dbPath);
+            this.initialized = true;
+            this.initSchema();
+            console.error('[IntelligenceStore] Warning: Using in-memory database (persistence disabled)');
+        }
+        catch {
+            // Complete failure - create a no-op stub
+            this.db = {
+                run: () => ({ lastInsertRowid: 0, changes: 0 }),
+                get: () => undefined,
+                all: () => [],
+                exec: () => { },
+                close: () => { },
+            };
+            this.initialized = true;
+            console.error('[IntelligenceStore] Warning: Database unavailable, intelligence features disabled');
+        }
+    }
+    /**
+     * Ensure database is initialized before operations
+     */
+    async ensureInitialized() {
+        if (!this.initialized) {
+            await this.initialize();
+        }
     }
     /**
      * Get singleton instance
@@ -53,6 +232,8 @@ export class IntelligenceStore {
      * Initialize database schema
      */
     initSchema() {
+        if (!this.db)
+            return;
         this.db.exec(`
       -- Trajectories table
       CREATE TABLE IF NOT EXISTS trajectories (
@@ -106,158 +287,158 @@ export class IntelligenceStore {
 
       -- Initialize stats row if not exists
       INSERT OR IGNORE INTO stats (id) VALUES (1);
-
-      -- Indexes for faster queries
-      CREATE INDEX IF NOT EXISTS idx_trajectories_agent ON trajectories(agent);
-      CREATE INDEX IF NOT EXISTS idx_trajectories_outcome ON trajectories(outcome);
-      CREATE INDEX IF NOT EXISTS idx_patterns_task_type ON patterns(task_type);
-      CREATE INDEX IF NOT EXISTS idx_routings_agent ON routings(recommended_agent);
-      CREATE INDEX IF NOT EXISTS idx_routings_timestamp ON routings(timestamp);
     `);
+        // Create indexes separately (sql.js doesn't support CREATE INDEX IF NOT EXISTS in exec)
+        try {
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_trajectories_agent ON trajectories(agent);`);
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_trajectories_outcome ON trajectories(outcome);`);
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_patterns_task_type ON patterns(task_type);`);
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_routings_agent ON routings(recommended_agent);`);
+            this.db.exec(`CREATE INDEX IF NOT EXISTS idx_routings_timestamp ON routings(timestamp);`);
+        }
+        catch {
+            // Indexes may already exist
+        }
     }
     // ============ Trajectory Methods ============
     /**
      * Start a new trajectory
      */
-    startTrajectory(taskDescription, agent) {
-        const stmt = this.db.prepare(`
-      INSERT INTO trajectories (task_description, agent, start_time)
-      VALUES (?, ?, ?)
-    `);
-        const result = stmt.run(taskDescription, agent, Date.now());
-        this.incrementStat('total_trajectories');
+    async startTrajectory(taskDescription, agent) {
+        await this.ensureInitialized();
+        if (!this.db)
+            return 0;
+        const result = this.db.run(`INSERT INTO trajectories (task_description, agent, start_time) VALUES (?, ?, ?)`, [taskDescription, agent, Date.now()]);
+        await this.incrementStat('total_trajectories');
         return result.lastInsertRowid;
     }
     /**
      * Add step to trajectory
      */
-    addTrajectoryStep(trajectoryId) {
-        const stmt = this.db.prepare(`
-      UPDATE trajectories SET steps = steps + 1 WHERE id = ?
-    `);
-        stmt.run(trajectoryId);
+    async addTrajectoryStep(trajectoryId) {
+        await this.ensureInitialized();
+        if (!this.db)
+            return;
+        this.db.run(`UPDATE trajectories SET steps = steps + 1 WHERE id = ?`, [trajectoryId]);
     }
     /**
      * End trajectory with outcome
      */
-    endTrajectory(trajectoryId, outcome, metadata) {
-        const stmt = this.db.prepare(`
-      UPDATE trajectories
-      SET outcome = ?, end_time = ?, metadata = ?
-      WHERE id = ?
-    `);
-        stmt.run(outcome, Date.now(), metadata ? JSON.stringify(metadata) : null, trajectoryId);
+    async endTrajectory(trajectoryId, outcome, metadata) {
+        await this.ensureInitialized();
+        if (!this.db)
+            return;
+        this.db.run(`UPDATE trajectories SET outcome = ?, end_time = ?, metadata = ? WHERE id = ?`, [outcome, Date.now(), metadata ? JSON.stringify(metadata) : null, trajectoryId]);
         if (outcome === 'success') {
-            this.incrementStat('successful_trajectories');
+            await this.incrementStat('successful_trajectories');
         }
     }
     /**
      * Get active trajectories (no end_time)
      */
-    getActiveTrajectories() {
-        const stmt = this.db.prepare(`
-      SELECT * FROM trajectories WHERE end_time IS NULL
-    `);
-        return stmt.all();
+    async getActiveTrajectories() {
+        await this.ensureInitialized();
+        if (!this.db)
+            return [];
+        return this.db.all(`SELECT * FROM trajectories WHERE end_time IS NULL`);
     }
     /**
      * Get recent trajectories
      */
-    getRecentTrajectories(limit = 10) {
-        const stmt = this.db.prepare(`
-      SELECT * FROM trajectories ORDER BY start_time DESC LIMIT ?
-    `);
-        return stmt.all(limit);
+    async getRecentTrajectories(limit = 10) {
+        await this.ensureInitialized();
+        if (!this.db)
+            return [];
+        return this.db.all(`SELECT * FROM trajectories ORDER BY start_time DESC LIMIT ?`, [limit]);
     }
     // ============ Pattern Methods ============
     /**
      * Store a pattern
      */
-    storePattern(taskType, approach, embedding) {
-        const stmt = this.db.prepare(`
-      INSERT INTO patterns (task_type, approach, embedding)
-      VALUES (?, ?, ?)
-    `);
+    async storePattern(taskType, approach, embedding) {
+        await this.ensureInitialized();
+        if (!this.db)
+            return 0;
         const embeddingBuffer = embedding ? Buffer.from(embedding.buffer) : null;
-        const result = stmt.run(taskType, approach, embeddingBuffer);
-        this.incrementStat('total_patterns');
+        const result = this.db.run(`INSERT INTO patterns (task_type, approach, embedding) VALUES (?, ?, ?)`, [taskType, approach, embeddingBuffer]);
+        await this.incrementStat('total_patterns');
         return result.lastInsertRowid;
     }
     /**
      * Update pattern usage
      */
-    updatePatternUsage(patternId, wasSuccessful) {
-        const stmt = this.db.prepare(`
-      UPDATE patterns
-      SET usage_count = usage_count + 1,
-          success_rate = (success_rate * usage_count + ?) / (usage_count + 1),
-          updated_at = strftime('%s', 'now')
-      WHERE id = ?
-    `);
-        stmt.run(wasSuccessful ? 1 : 0, patternId);
+    async updatePatternUsage(patternId, wasSuccessful) {
+        await this.ensureInitialized();
+        if (!this.db)
+            return;
+        this.db.run(`UPDATE patterns SET usage_count = usage_count + 1, success_rate = (success_rate * usage_count + ?) / (usage_count + 1), updated_at = strftime('%s', 'now') WHERE id = ?`, [wasSuccessful ? 1 : 0, patternId]);
     }
     /**
      * Find patterns by task type
      */
-    findPatterns(taskType, limit = 5) {
-        const stmt = this.db.prepare(`
-      SELECT * FROM patterns
-      WHERE task_type LIKE ?
-      ORDER BY success_rate DESC, usage_count DESC
-      LIMIT ?
-    `);
-        return stmt.all(`%${taskType}%`, limit);
+    async findPatterns(taskType, limit = 5) {
+        await this.ensureInitialized();
+        if (!this.db)
+            return [];
+        return this.db.all(`SELECT * FROM patterns WHERE task_type LIKE ? ORDER BY success_rate DESC, usage_count DESC LIMIT ?`, [`%${taskType}%`, limit]);
     }
     // ============ Routing Methods ============
     /**
      * Record a routing decision
      */
-    recordRouting(task, recommendedAgent, confidence, latencyMs) {
-        const stmt = this.db.prepare(`
-      INSERT INTO routings (task, recommended_agent, confidence, latency_ms)
-      VALUES (?, ?, ?, ?)
-    `);
-        const result = stmt.run(task, recommendedAgent, confidence, latencyMs);
-        this.incrementStat('total_routings');
+    async recordRouting(task, recommendedAgent, confidence, latencyMs) {
+        await this.ensureInitialized();
+        if (!this.db)
+            return 0;
+        const result = this.db.run(`INSERT INTO routings (task, recommended_agent, confidence, latency_ms) VALUES (?, ?, ?, ?)`, [task, recommendedAgent, confidence, latencyMs]);
+        await this.incrementStat('total_routings');
         return result.lastInsertRowid;
     }
     /**
      * Update routing outcome
      */
-    updateRoutingOutcome(routingId, wasSuccessful) {
-        const stmt = this.db.prepare(`
-      UPDATE routings SET was_successful = ? WHERE id = ?
-    `);
-        stmt.run(wasSuccessful ? 1 : 0, routingId);
+    async updateRoutingOutcome(routingId, wasSuccessful) {
+        await this.ensureInitialized();
+        if (!this.db)
+            return;
+        this.db.run(`UPDATE routings SET was_successful = ? WHERE id = ?`, [wasSuccessful ? 1 : 0, routingId]);
         if (wasSuccessful) {
-            this.incrementStat('successful_routings');
+            await this.incrementStat('successful_routings');
         }
     }
     /**
      * Get routing accuracy for an agent
      */
-    getAgentAccuracy(agent) {
-        const stmt = this.db.prepare(`
-      SELECT
-        COUNT(*) as total,
-        SUM(was_successful) as successful
-      FROM routings
-      WHERE recommended_agent = ?
-    `);
-        const result = stmt.get(agent);
+    async getAgentAccuracy(agent) {
+        await this.ensureInitialized();
+        if (!this.db)
+            return { total: 0, successful: 0, accuracy: 0 };
+        const result = this.db.get(`SELECT COUNT(*) as total, SUM(was_successful) as successful FROM routings WHERE recommended_agent = ?`, [agent]);
         return {
-            total: result.total || 0,
-            successful: result.successful || 0,
-            accuracy: result.total > 0 ? (result.successful || 0) / result.total : 0,
+            total: result?.total || 0,
+            successful: result?.successful || 0,
+            accuracy: result?.total ? (result.successful || 0) / result.total : 0,
         };
     }
     // ============ Stats Methods ============
     /**
      * Get all stats
      */
-    getStats() {
-        const stmt = this.db.prepare(`SELECT * FROM stats WHERE id = 1`);
-        const row = stmt.get();
+    async getStats() {
+        await this.ensureInitialized();
+        if (!this.db) {
+            return {
+                totalTrajectories: 0,
+                successfulTrajectories: 0,
+                totalRoutings: 0,
+                successfulRoutings: 0,
+                totalPatterns: 0,
+                sonaAdaptations: 0,
+                hnswQueries: 0,
+                lastUpdated: Date.now(),
+            };
+        }
+        const row = this.db.get(`SELECT * FROM stats WHERE id = 1`);
         return {
             totalTrajectories: row?.total_trajectories || 0,
             successfulTrajectories: row?.successful_trajectories || 0,
@@ -272,31 +453,30 @@ export class IntelligenceStore {
     /**
      * Increment a stat counter
      */
-    incrementStat(statName, amount = 1) {
-        const stmt = this.db.prepare(`
-      UPDATE stats SET ${statName} = ${statName} + ?, last_updated = strftime('%s', 'now')
-      WHERE id = 1
-    `);
-        stmt.run(amount);
+    async incrementStat(statName, amount = 1) {
+        await this.ensureInitialized();
+        if (!this.db)
+            return;
+        this.db.run(`UPDATE stats SET ${statName} = ${statName} + ?, last_updated = strftime('%s', 'now') WHERE id = 1`, [amount]);
     }
     /**
      * Record SONA adaptation
      */
-    recordSonaAdaptation() {
-        this.incrementStat('sona_adaptations');
+    async recordSonaAdaptation() {
+        await this.incrementStat('sona_adaptations');
     }
     /**
      * Record HNSW query
      */
-    recordHnswQuery() {
-        this.incrementStat('hnsw_queries');
+    async recordHnswQuery() {
+        await this.incrementStat('hnsw_queries');
     }
     // ============ Utility Methods ============
     /**
      * Get summary for display (simplified for UI)
      */
-    getSummary() {
-        const stats = this.getStats();
+    async getSummary() {
+        const stats = await this.getStats();
         return {
             trajectories: stats.totalTrajectories,
             routings: stats.totalRoutings,
@@ -307,20 +487,18 @@ export class IntelligenceStore {
     /**
      * Get detailed summary for reports
      */
-    getDetailedSummary() {
-        const stats = this.getStats();
-        const activeCount = this.getActiveTrajectories().length;
+    async getDetailedSummary() {
+        const stats = await this.getStats();
+        const active = await this.getActiveTrajectories();
         return {
             trajectories: {
                 total: stats.totalTrajectories,
-                active: activeCount,
+                active: active.length,
                 successful: stats.successfulTrajectories,
             },
             routings: {
                 total: stats.totalRoutings,
-                accuracy: stats.totalRoutings > 0
-                    ? stats.successfulRoutings / stats.totalRoutings
-                    : 0,
+                accuracy: stats.totalRoutings > 0 ? stats.successfulRoutings / stats.totalRoutings : 0,
             },
             patterns: stats.totalPatterns,
             operations: {
@@ -333,13 +511,20 @@ export class IntelligenceStore {
      * Close database connection
      */
     close() {
-        this.db.close();
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+        this.initialized = false;
         IntelligenceStore.instance = null;
     }
     /**
      * Reset all data (for testing)
      */
-    reset() {
+    async reset() {
+        await this.ensureInitialized();
+        if (!this.db)
+            return;
         this.db.exec(`
       DELETE FROM trajectories;
       DELETE FROM patterns;