@soleri/core 2.1.0 → 2.5.0

package/dist/vault/vault.js

@@ -1,21 +1,39 @@
-import Database from 'better-sqlite3';
-import { mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
+import { SQLitePersistenceProvider } from '../persistence/sqlite-provider.js';
 export class Vault {
-    db;
-    constructor(dbPath = ':memory:') {
-        if (dbPath !== ':memory:')
-            mkdirSync(dirname(dbPath), { recursive: true });
-        this.db = new Database(dbPath);
-        this.db.pragma('journal_mode = WAL');
-        this.db.pragma('foreign_keys = ON');
+    provider;
+    sqliteProvider;
+    syncManager = null;
+    /**
+     * Create a Vault with a PersistenceProvider or a SQLite path (backward compat).
+     */
+    constructor(providerOrPath = ':memory:') {
+        if (typeof providerOrPath === 'string') {
+            const sqlite = new SQLitePersistenceProvider(providerOrPath);
+            this.provider = sqlite;
+            this.sqliteProvider = sqlite;
+            // SQLite-specific pragmas
+            this.provider.run('PRAGMA journal_mode = WAL');
+            this.provider.run('PRAGMA foreign_keys = ON');
+        }
+        else {
+            this.provider = providerOrPath;
+            this.sqliteProvider =
+                providerOrPath instanceof SQLitePersistenceProvider ? providerOrPath : null;
+        }
         this.initialize();
     }
+    setSyncManager(mgr) {
+        this.syncManager = mgr;
+    }
+    /** Backward-compatible factory. */
+    static createWithSQLite(dbPath = ':memory:') {
+        return new Vault(dbPath);
+    }
     initialize() {
-        this.db.exec(`
+        this.provider.execSql(`
       CREATE TABLE IF NOT EXISTS entries (
         id TEXT PRIMARY KEY,
-        type TEXT NOT NULL CHECK(type IN ('pattern', 'anti-pattern', 'rule')),
+        type TEXT NOT NULL CHECK(type IN ('pattern', 'anti-pattern', 'rule', 'playbook')),
         domain TEXT NOT NULL,
         title TEXT NOT NULL,
         severity TEXT NOT NULL CHECK(severity IN ('critical', 'warning', 'suggestion')),
@@ -83,24 +101,83 @@ export class Vault {
         id INTEGER PRIMARY KEY AUTOINCREMENT,
         query TEXT NOT NULL,
         entry_id TEXT NOT NULL,
-        action TEXT NOT NULL CHECK(action IN ('accepted', 'dismissed')),
+        action TEXT NOT NULL CHECK(action IN ('accepted', 'dismissed', 'modified', 'failed')),
+        source TEXT NOT NULL DEFAULT 'search',
+        confidence REAL NOT NULL DEFAULT 0.6,
+        duration INTEGER,
+        context TEXT NOT NULL DEFAULT '{}',
+        reason TEXT,
         created_at INTEGER NOT NULL DEFAULT (unixepoch())
       );
       CREATE INDEX IF NOT EXISTS idx_brain_feedback_query ON brain_feedback(query);
     `);
+        this.migrateBrainSchema();
+        this.migrateTemporalSchema();
+    }
+    migrateTemporalSchema() {
+        try {
+            this.provider.run('ALTER TABLE entries ADD COLUMN valid_from INTEGER');
+        }
+        catch {
+            // Column already exists
+        }
+        try {
+            this.provider.run('ALTER TABLE entries ADD COLUMN valid_until INTEGER');
+        }
+        catch {
+            // Column already exists
+        }
+    }
+    migrateBrainSchema() {
+        const columns = this.provider.all('PRAGMA table_info(brain_feedback)');
+        const hasSource = columns.some((c) => c.name === 'source');
+        if (!hasSource && columns.length > 0) {
+            this.provider.transaction(() => {
+                this.provider.run(`
+          CREATE TABLE brain_feedback_new (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            query TEXT NOT NULL,
+            entry_id TEXT NOT NULL,
+            action TEXT NOT NULL CHECK(action IN ('accepted', 'dismissed', 'modified', 'failed')),
+            source TEXT NOT NULL DEFAULT 'search',
+            confidence REAL NOT NULL DEFAULT 0.6,
+            duration INTEGER,
+            context TEXT NOT NULL DEFAULT '{}',
+            reason TEXT,
+            created_at INTEGER NOT NULL DEFAULT (unixepoch())
+          )
+        `);
+                this.provider.run(`
+          INSERT INTO brain_feedback_new (id, query, entry_id, action, created_at)
+            SELECT id, query, entry_id, action, created_at FROM brain_feedback
+        `);
+                this.provider.run('DROP TABLE brain_feedback');
+                this.provider.run('ALTER TABLE brain_feedback_new RENAME TO brain_feedback');
+                this.provider.run('CREATE INDEX IF NOT EXISTS idx_brain_feedback_query ON brain_feedback(query)');
+            });
+        }
+        try {
+            const sessionCols = this.provider.all('PRAGMA table_info(brain_sessions)');
+            if (sessionCols.length > 0 && !sessionCols.some((c) => c.name === 'extracted_at')) {
+                this.provider.run('ALTER TABLE brain_sessions ADD COLUMN extracted_at TEXT');
+            }
+        }
+        catch {
+            // brain_sessions table doesn't exist yet — BrainIntelligence will create it
+        }
     }
     seed(entries) {
-        const upsert = this.db.prepare(`
-      INSERT INTO entries (id,type,domain,title,severity,description,context,example,counter_example,why,tags,applies_to)
-      VALUES (@id,@type,@domain,@title,@severity,@description,@context,@example,@counterExample,@why,@tags,@appliesTo)
+        const sql = `
+      INSERT INTO entries (id,type,domain,title,severity,description,context,example,counter_example,why,tags,applies_to,valid_from,valid_until)
+      VALUES (@id,@type,@domain,@title,@severity,@description,@context,@example,@counterExample,@why,@tags,@appliesTo,@validFrom,@validUntil)
       ON CONFLICT(id) DO UPDATE SET type=excluded.type,domain=excluded.domain,title=excluded.title,severity=excluded.severity,
         description=excluded.description,context=excluded.context,example=excluded.example,counter_example=excluded.counter_example,
-        why=excluded.why,tags=excluded.tags,applies_to=excluded.applies_to,updated_at=unixepoch()
-    `);
-        const tx = this.db.transaction((items) => {
+        why=excluded.why,tags=excluded.tags,applies_to=excluded.applies_to,valid_from=excluded.valid_from,valid_until=excluded.valid_until,updated_at=unixepoch()
+    `;
+        return this.provider.transaction(() => {
             let count = 0;
-            for (const entry of items) {
-                upsert.run({
+            for (const entry of entries) {
+                this.provider.run(sql, {
                     id: entry.id,
                     type: entry.type,
                     domain: entry.domain,
@@ -113,12 +190,16 @@ export class Vault {
                     why: entry.why ?? null,
                     tags: JSON.stringify(entry.tags),
                     appliesTo: JSON.stringify(entry.appliesTo ?? []),
+                    validFrom: entry.validFrom ?? null,
+                    validUntil: entry.validUntil ?? null,
                 });
                 count++;
+                if (this.syncManager) {
+                    this.syncManager.enqueue('ingest', entry.id, entry);
+                }
             }
             return count;
         });
-        return tx(entries);
     }
     search(query, options) {
         const limit = options?.limit ?? 10;
@@ -136,11 +217,15 @@ export class Vault {
             filters.push('e.severity = @severity');
             fp.severity = options.severity;
         }
+        if (!options?.includeExpired) {
+            const now = Math.floor(Date.now() / 1000);
+            filters.push('(e.valid_until IS NULL OR e.valid_until > @now)');
+            filters.push('(e.valid_from IS NULL OR e.valid_from <= @now)');
+            fp.now = now;
+        }
         const wc = filters.length > 0 ? `AND ${filters.join(' AND ')}` : '';
         try {
-            const rows = this.db
-                .prepare(`SELECT e.*, -rank as score FROM entries_fts fts JOIN entries e ON e.rowid = fts.rowid WHERE entries_fts MATCH @query ${wc} ORDER BY score DESC LIMIT @limit`)
-                .all({ query, limit, ...fp });
+            const rows = this.provider.all(`SELECT e.*, -rank as score FROM entries_fts fts JOIN entries e ON e.rowid = fts.rowid WHERE entries_fts MATCH @query ${wc} ORDER BY score DESC LIMIT @limit`, { query, limit, ...fp });
             return rows.map(rowToSearchResult);
         }
         catch {
@@ -148,7 +233,9 @@ export class Vault {
         }
     }
     get(id) {
-        const row = this.db.prepare('SELECT * FROM entries WHERE id = ?').get(id);
+        const row = this.provider.get('SELECT * FROM entries WHERE id = ?', [
+            id,
+        ]);
         return row ? rowToEntry(row) : null;
     }
     list(options) {
@@ -173,41 +260,153 @@ export class Vault {
             });
             filters.push(`(${c.join(' OR ')})`);
         }
+        if (!options?.includeExpired) {
+            const now = Math.floor(Date.now() / 1000);
+            filters.push('(valid_until IS NULL OR valid_until > @now)');
+            filters.push('(valid_from IS NULL OR valid_from <= @now)');
+            params.now = now;
+        }
         const wc = filters.length > 0 ? `WHERE ${filters.join(' AND ')}` : '';
-        const rows = this.db
-            .prepare(`SELECT * FROM entries ${wc} ORDER BY severity, domain, title LIMIT @limit OFFSET @offset`)
-            .all({ ...params, limit: options?.limit ?? 50, offset: options?.offset ?? 0 });
+        const rows = this.provider.all(`SELECT * FROM entries ${wc} ORDER BY severity, domain, title LIMIT @limit OFFSET @offset`, { ...params, limit: options?.limit ?? 50, offset: options?.offset ?? 0 });
         return rows.map(rowToEntry);
     }
     stats() {
-        const total = this.db.prepare('SELECT COUNT(*) as count FROM entries').get().count;
+        const total = this.provider.get('SELECT COUNT(*) as count FROM entries').count;
         return {
             totalEntries: total,
-            byType: gc(this.db, 'type'),
-            byDomain: gc(this.db, 'domain'),
-            bySeverity: gc(this.db, 'severity'),
+            byType: gc(this.provider, 'type'),
+            byDomain: gc(this.provider, 'domain'),
+            bySeverity: gc(this.provider, 'severity'),
         };
     }
     add(entry) {
         this.seed([entry]);
     }
     remove(id) {
-        return this.db.prepare('DELETE FROM entries WHERE id = ?').run(id).changes > 0;
+        const deleted = this.provider.run('DELETE FROM entries WHERE id = ?', [id]).changes > 0;
+        if (deleted && this.syncManager) {
+            this.syncManager.enqueue('delete', id);
+        }
+        return deleted;
+    }
+    update(id, fields) {
+        const existing = this.get(id);
+        if (!existing)
+            return null;
+        const merged = { ...existing, ...fields };
+        this.seed([merged]);
+        return this.get(id);
+    }
+    setTemporal(id, validFrom, validUntil) {
+        const sets = [];
+        const params = { id };
+        if (validFrom !== undefined) {
+            sets.push('valid_from = @validFrom');
+            params.validFrom = validFrom;
+        }
+        if (validUntil !== undefined) {
+            sets.push('valid_until = @validUntil');
+            params.validUntil = validUntil;
+        }
+        if (sets.length === 0)
+            return false;
+        sets.push('updated_at = unixepoch()');
+        return (this.provider.run(`UPDATE entries SET ${sets.join(', ')} WHERE id = @id`, params).changes > 0);
+    }
+    findExpiring(withinDays) {
+        const now = Math.floor(Date.now() / 1000);
+        const cutoff = now + withinDays * 86400;
+        const rows = this.provider.all('SELECT * FROM entries WHERE valid_until IS NOT NULL AND valid_until > @now AND valid_until <= @cutoff ORDER BY valid_until ASC', { now, cutoff });
+        return rows.map(rowToEntry);
+    }
+    findExpired(limit = 50) {
+        const now = Math.floor(Date.now() / 1000);
+        const rows = this.provider.all('SELECT * FROM entries WHERE valid_until IS NOT NULL AND valid_until <= @now ORDER BY valid_until DESC LIMIT @limit', { now, limit });
+        return rows.map(rowToEntry);
+    }
+    bulkRemove(ids) {
+        return this.provider.transaction(() => {
+            let count = 0;
+            for (const id of ids) {
+                count += this.provider.run('DELETE FROM entries WHERE id = ?', [id]).changes;
+                if (this.syncManager) {
+                    this.syncManager.enqueue('delete', id);
+                }
+            }
+            return count;
+        });
+    }
+    getTags() {
+        const rows = this.provider.all('SELECT tags FROM entries');
+        const counts = new Map();
+        for (const row of rows) {
+            const tags = JSON.parse(row.tags || '[]');
+            for (const tag of tags) {
+                counts.set(tag, (counts.get(tag) ?? 0) + 1);
+            }
+        }
+        return Array.from(counts.entries())
+            .map(([tag, count]) => ({ tag, count }))
+            .sort((a, b) => b.count - a.count);
+    }
+    getDomains() {
+        return this.provider.all('SELECT domain, COUNT(*) as count FROM entries GROUP BY domain ORDER BY count DESC');
+    }
+    getRecent(limit = 20) {
+        const rows = this.provider.all('SELECT * FROM entries ORDER BY updated_at DESC LIMIT ?', [limit]);
+        return rows.map(rowToEntry);
+    }
+    exportAll() {
+        const rows = this.provider.all('SELECT * FROM entries ORDER BY domain, title');
+        const entries = rows.map(rowToEntry);
+        return { entries, exportedAt: Math.floor(Date.now() / 1000), count: entries.length };
+    }
+    getAgeReport() {
+        const rows = this.provider.all('SELECT created_at, updated_at FROM entries');
+        const now = Math.floor(Date.now() / 1000);
+        const bucketDefs = [
+            { label: 'today', minDays: 0, maxDays: 1 },
+            { label: 'this_week', minDays: 1, maxDays: 7 },
+            { label: 'this_month', minDays: 7, maxDays: 30 },
+            { label: 'this_quarter', minDays: 30, maxDays: 90 },
+            { label: 'older', minDays: 90, maxDays: Infinity },
+        ];
+        const counts = new Array(bucketDefs.length).fill(0);
+        let oldest = null;
+        let newest = null;
+        for (const row of rows) {
+            const ts = row.created_at;
+            if (oldest === null || ts < oldest)
+                oldest = ts;
+            if (newest === null || ts > newest)
+                newest = ts;
+            const ageDays = (now - ts) / 86400;
+            for (let i = 0; i < bucketDefs.length; i++) {
+                if (ageDays >= bucketDefs[i].minDays && ageDays < bucketDefs[i].maxDays) {
+                    counts[i]++;
+                    break;
+                }
+            }
+        }
+        return {
+            total: rows.length,
+            buckets: bucketDefs.map((b, i) => ({ ...b, count: counts[i] })),
+            oldestTimestamp: oldest,
+            newestTimestamp: newest,
+        };
     }
     registerProject(path, name) {
         const projectName = name ?? path.replace(/\/$/, '').split('/').pop() ?? path;
         const existing = this.getProject(path);
         if (existing) {
-            this.db
-                .prepare('UPDATE projects SET last_seen_at = unixepoch(), session_count = session_count + 1 WHERE path = ?')
-                .run(path);
+            this.provider.run('UPDATE projects SET last_seen_at = unixepoch(), session_count = session_count + 1 WHERE path = ?', [path]);
             return this.getProject(path);
         }
-        this.db.prepare('INSERT INTO projects (path, name) VALUES (?, ?)').run(path, projectName);
+        this.provider.run('INSERT INTO projects (path, name) VALUES (?, ?)', [path, projectName]);
         return this.getProject(path);
     }
     getProject(path) {
-        const row = this.db.prepare('SELECT * FROM projects WHERE path = ?').get(path);
+        const row = this.provider.get('SELECT * FROM projects WHERE path = ?', [path]);
         if (!row)
             return null;
         return {
@@ -219,9 +418,7 @@ export class Vault {
         };
     }
     listProjects() {
-        const rows = this.db
-            .prepare('SELECT * FROM projects ORDER BY last_seen_at DESC')
-            .all();
+        const rows = this.provider.all('SELECT * FROM projects ORDER BY last_seen_at DESC');
         return rows.map((row) => ({
             path: row.path,
             name: row.name,
@@ -232,9 +429,7 @@ export class Vault {
     }
     captureMemory(memory) {
         const id = `mem-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        this.db
-            .prepare(`INSERT INTO memories (id, project_path, type, context, summary, topics, files_modified, tools_used) VALUES (@id, @projectPath, @type, @context, @summary, @topics, @filesModified, @toolsUsed)`)
-            .run({
+        this.provider.run(`INSERT INTO memories (id, project_path, type, context, summary, topics, files_modified, tools_used) VALUES (@id, @projectPath, @type, @context, @summary, @topics, @filesModified, @toolsUsed)`, {
             id,
             projectPath: memory.projectPath,
             type: memory.type,
@@ -260,9 +455,7 @@ export class Vault {
         }
         const wc = filters.length > 0 ? `AND ${filters.join(' AND ')}` : '';
         try {
-            const rows = this.db
-                .prepare(`SELECT m.* FROM memories_fts fts JOIN memories m ON m.rowid = fts.rowid WHERE memories_fts MATCH @query ${wc} ORDER BY rank LIMIT @limit`)
-                .all({ query, limit, ...fp });
+            const rows = this.provider.all(`SELECT m.* FROM memories_fts fts JOIN memories m ON m.rowid = fts.rowid WHERE memories_fts MATCH @query ${wc} ORDER BY rank LIMIT @limit`, { query, limit, ...fp });
             return rows.map(rowToMemory);
         }
         catch {
@@ -281,19 +474,13 @@ export class Vault {
             params.projectPath = options.projectPath;
         }
         const wc = `WHERE ${filters.join(' AND ')}`;
-        const rows = this.db
-            .prepare(`SELECT * FROM memories ${wc} ORDER BY created_at DESC LIMIT @limit OFFSET @offset`)
-            .all({ ...params, limit: options?.limit ?? 50, offset: options?.offset ?? 0 });
+        const rows = this.provider.all(`SELECT * FROM memories ${wc} ORDER BY created_at DESC LIMIT @limit OFFSET @offset`, { ...params, limit: options?.limit ?? 50, offset: options?.offset ?? 0 });
         return rows.map(rowToMemory);
     }
     memoryStats() {
-        const total = this.db.prepare('SELECT COUNT(*) as count FROM memories WHERE archived_at IS NULL').get().count;
-        const byTypeRows = this.db
-            .prepare('SELECT type as key, COUNT(*) as count FROM memories WHERE archived_at IS NULL GROUP BY type')
-            .all();
-        const byProjectRows = this.db
-            .prepare('SELECT project_path as key, COUNT(*) as count FROM memories WHERE archived_at IS NULL GROUP BY project_path')
-            .all();
+        const total = this.provider.get('SELECT COUNT(*) as count FROM memories WHERE archived_at IS NULL').count;
+        const byTypeRows = this.provider.all('SELECT type as key, COUNT(*) as count FROM memories WHERE archived_at IS NULL GROUP BY type');
+        const byProjectRows = this.provider.all('SELECT project_path as key, COUNT(*) as count FROM memories WHERE archived_at IS NULL GROUP BY project_path');
         return {
             total,
             byType: Object.fromEntries(byTypeRows.map((r) => [r.key, r.count])),
@@ -301,20 +488,190 @@ export class Vault {
         };
     }
     getMemory(id) {
-        const row = this.db.prepare('SELECT * FROM memories WHERE id = ?').get(id);
+        const row = this.provider.get('SELECT * FROM memories WHERE id = ?', [
+            id,
+        ]);
         return row ? rowToMemory(row) : null;
     }
+    deleteMemory(id) {
+        return this.provider.run('DELETE FROM memories WHERE id = ?', [id]).changes > 0;
+    }
+    memoryStatsDetailed(options) {
+        const filters = [];
+        const params = {};
+        if (options?.projectPath) {
+            filters.push('project_path = @projectPath');
+            params.projectPath = options.projectPath;
+        }
+        if (options?.fromDate) {
+            filters.push('created_at >= @fromDate');
+            params.fromDate = options.fromDate;
+        }
+        if (options?.toDate) {
+            filters.push('created_at <= @toDate');
+            params.toDate = options.toDate;
+        }
+        const wc = filters.length > 0 ? `WHERE ${filters.join(' AND ')}` : '';
+        const total = this.provider.get(`SELECT COUNT(*) as count FROM memories ${wc}${wc ? ' AND' : ' WHERE'} archived_at IS NULL`, params).count;
+        const archivedCount = this.provider.get(`SELECT COUNT(*) as count FROM memories ${wc}${wc ? ' AND' : ' WHERE'} archived_at IS NOT NULL`, params).count;
+        const byTypeRows = this.provider.all(`SELECT type as key, COUNT(*) as count FROM memories ${wc}${wc ? ' AND' : ' WHERE'} archived_at IS NULL GROUP BY type`, params);
+        const byProjectRows = this.provider.all(`SELECT project_path as key, COUNT(*) as count FROM memories ${wc}${wc ? ' AND' : ' WHERE'} archived_at IS NULL GROUP BY project_path`, params);
+        const dateRange = this.provider.get(`SELECT MIN(created_at) as oldest, MAX(created_at) as newest FROM memories ${wc}${wc ? ' AND' : ' WHERE'} archived_at IS NULL`, params);
+        return {
+            total,
+            byType: Object.fromEntries(byTypeRows.map((r) => [r.key, r.count])),
+            byProject: Object.fromEntries(byProjectRows.map((r) => [r.key, r.count])),
+            oldest: dateRange.oldest,
+            newest: dateRange.newest,
+            archivedCount,
+        };
+    }
+    exportMemories(options) {
+        const filters = [];
+        const params = {};
+        if (!options?.includeArchived) {
+            filters.push('archived_at IS NULL');
+        }
+        if (options?.projectPath) {
+            filters.push('project_path = @projectPath');
+            params.projectPath = options.projectPath;
+        }
+        if (options?.type) {
+            filters.push('type = @type');
+            params.type = options.type;
+        }
+        const wc = filters.length > 0 ? `WHERE ${filters.join(' AND ')}` : '';
+        const rows = this.provider.all(`SELECT * FROM memories ${wc} ORDER BY created_at ASC`, Object.keys(params).length > 0 ? params : undefined);
+        return rows.map(rowToMemory);
+    }
+    importMemories(memories) {
+        const sql = `
+      INSERT OR IGNORE INTO memories (id, project_path, type, context, summary, topics, files_modified, tools_used, created_at, archived_at)
+      VALUES (@id, @projectPath, @type, @context, @summary, @topics, @filesModified, @toolsUsed, @createdAt, @archivedAt)
+    `;
+        let imported = 0;
+        let skipped = 0;
+        this.provider.transaction(() => {
+            for (const m of memories) {
+                const result = this.provider.run(sql, {
+                    id: m.id,
+                    projectPath: m.projectPath,
+                    type: m.type,
+                    context: m.context,
+                    summary: m.summary,
+                    topics: JSON.stringify(m.topics),
+                    filesModified: JSON.stringify(m.filesModified),
+                    toolsUsed: JSON.stringify(m.toolsUsed),
+                    createdAt: m.createdAt,
+                    archivedAt: m.archivedAt,
+                });
+                if (result.changes > 0)
+                    imported++;
+                else
+                    skipped++;
+            }
+        });
+        return { imported, skipped };
+    }
+    pruneMemories(olderThanDays) {
+        const cutoff = Math.floor(Date.now() / 1000) - olderThanDays * 86400;
+        const result = this.provider.run('DELETE FROM memories WHERE created_at < ? AND archived_at IS NULL', [cutoff]);
+        return { pruned: result.changes };
+    }
+    deduplicateMemories() {
+        const dupeRows = this.provider.all(`
+        SELECT m1.id as id1, m2.id as id2
+        FROM memories m1
+        JOIN memories m2 ON m1.summary = m2.summary
+          AND m1.project_path = m2.project_path
+          AND m1.type = m2.type
+          AND m1.id < m2.id
+          AND m1.archived_at IS NULL
+          AND m2.archived_at IS NULL
+      `);
+        const groupMap = new Map();
+        for (const row of dupeRows) {
+            if (!groupMap.has(row.id1))
+                groupMap.set(row.id1, new Set());
+            groupMap.get(row.id1).add(row.id2);
+        }
+        const groups = [];
+        const toRemove = new Set();
+        for (const [kept, removedSet] of groupMap) {
+            const removed = [...removedSet].filter((id) => !toRemove.has(id));
+            if (removed.length > 0) {
+                groups.push({ kept, removed });
+                for (const id of removed)
+                    toRemove.add(id);
+            }
+        }
+        if (toRemove.size > 0) {
+            this.provider.transaction(() => {
+                for (const id of toRemove) {
+                    this.provider.run('DELETE FROM memories WHERE id = ?', [id]);
+                }
+            });
+        }
+        return { removed: toRemove.size, groups };
+    }
+    memoryTopics() {
+        const rows = this.provider.all('SELECT topics FROM memories WHERE archived_at IS NULL');
+        const topicCounts = new Map();
+        for (const row of rows) {
+            const topics = JSON.parse(row.topics || '[]');
+            for (const topic of topics) {
+                topicCounts.set(topic, (topicCounts.get(topic) ?? 0) + 1);
+            }
+        }
+        return [...topicCounts.entries()]
+            .map(([topic, count]) => ({ topic, count }))
+            .sort((a, b) => b.count - a.count);
+    }
+    memoriesByProject() {
+        const rows = this.provider.all('SELECT project_path as project, COUNT(*) as count FROM memories WHERE archived_at IS NULL GROUP BY project_path ORDER BY count DESC');
+        return rows.map((row) => {
+            const memories = this.provider.all('SELECT * FROM memories WHERE project_path = ? AND archived_at IS NULL ORDER BY created_at DESC', [row.project]);
+            return {
+                project: row.project,
+                count: row.count,
+                memories: memories.map(rowToMemory),
+            };
+        });
+    }
+    /**
+     * Rebuild the FTS5 index for the entries table.
+     * Useful after bulk operations or if the index gets out of sync.
+     */
+    rebuildFtsIndex() {
+        try {
+            this.provider.run("INSERT INTO entries_fts(entries_fts) VALUES('rebuild')");
+        }
+        catch {
+            // Graceful degradation — FTS rebuild failed (e.g. table doesn't exist yet)
+        }
+    }
+    /**
+     * Get the underlying persistence provider.
+     */
+    getProvider() {
+        return this.provider;
+    }
+    /**
+     * Get the raw better-sqlite3 Database (backward compat).
+     * Throws if the provider is not SQLite.
+     */
     getDb() {
-        return this.db;
+        if (this.sqliteProvider) {
+            return this.sqliteProvider.getDatabase();
+        }
+        throw new Error('getDb() is only available with SQLite provider');
     }
     close() {
-        this.db.close();
+        this.provider.close();
     }
 }
-function gc(db, col) {
-    const rows = db
-        .prepare(`SELECT ${col} as key, COUNT(*) as count FROM entries GROUP BY ${col}`)
-        .all();
+function gc(provider, col) {
+    const rows = provider.all(`SELECT ${col} as key, COUNT(*) as count FROM entries GROUP BY ${col}`);
     return Object.fromEntries(rows.map((r) => [r.key, r.count]));
 }
 function rowToEntry(row) {
@@ -331,6 +688,8 @@ function rowToEntry(row) {
         why: row.why ?? undefined,
         tags: JSON.parse(row.tags || '[]'),
         appliesTo: JSON.parse(row.applies_to || '[]'),
+        validFrom: row.valid_from ?? undefined,
+        validUntil: row.valid_until ?? undefined,
     };
 }
 function rowToSearchResult(row) {