moflo 4.0.2 → 4.0.4

package/v3/@claude-flow/memory/dist/rvf-learning-store.js

@@ -0,0 +1,295 @@
+/**
+ * RvfLearningStore - Persistent storage for SONA learning artifacts
+ *
+ * Stores patterns, LoRA adapters, EWC state, and trajectories in a
+ * binary-header JSON-lines file format for fast append and rebuild.
+ *
+ * File format:
+ *   4-byte magic "RVLS" + newline
+ *   One JSON record per line: {"type":"pattern"|"lora"|"ewc"|"trajectory","data":{...}}
+ *
+ * @module @claude-flow/memory/rvf-learning-store
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+// ===== Constants =====
+const MAGIC_HEADER = 'RVLS';
+const DEFAULT_DIMENSIONS = 64;
+const DEFAULT_AUTO_PERSIST_MS = 30_000;
+// ===== Helpers =====
+function ensureDirectory(filePath) {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+// ===== RvfLearningStore =====
+/**
+ * Persistent store for SONA learning artifacts.
+ *
+ * Maintains in-memory maps for fast reads and flushes to a JSON-lines
+ * file with a binary header on persist(). On initialize(), the file is
+ * read line-by-line to rebuild state.
+ *
+ * @example
+ * ```typescript
+ * const store = new RvfLearningStore({ storePath: './data/learning.rvls' });
+ * await store.initialize();
+ *
+ * await store.savePatterns([{ id: 'p1', type: 'query_response', ... }]);
+ * await store.persist();
+ * await store.close();
+ * ```
+ */
+export class RvfLearningStore {
+    config;
+    patterns = new Map();
+    loraAdapters = new Map();
+    ewcState = null;
+    trajectories = [];
+    dirty = false;
+    initialized = false;
+    autoPersistTimer = null;
+    constructor(config) {
+        this.config = {
+            storePath: config.storePath,
+            dimensions: config.dimensions ?? DEFAULT_DIMENSIONS,
+            autoPersistInterval: config.autoPersistInterval ?? DEFAULT_AUTO_PERSIST_MS,
+            verbose: config.verbose ?? false,
+        };
+    }
+    /**
+     * Initialize the store by loading any existing data from disk.
+     * Creates the parent directory if it does not exist.
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        ensureDirectory(this.config.storePath);
+        if (fs.existsSync(this.config.storePath)) {
+            await this.loadFromDisk();
+        }
+        if (this.config.autoPersistInterval > 0) {
+            this.autoPersistTimer = setInterval(() => void this.persist().catch(() => { }), this.config.autoPersistInterval);
+            // Allow the process to exit even if the timer is active
+            if (this.autoPersistTimer.unref) {
+                this.autoPersistTimer.unref();
+            }
+        }
+        this.initialized = true;
+        this.log('Store initialized');
+    }
+    // ===== Pattern operations =====
+    /**
+     * Save or update patterns. Existing patterns with matching IDs are
+     * overwritten; new patterns are added.
+     *
+     * @returns The number of patterns stored
+     */
+    async savePatterns(patterns) {
+        this.ensureInitialized();
+        let count = 0;
+        for (const pattern of patterns) {
+            this.patterns.set(pattern.id, { ...pattern });
+            count++;
+        }
+        this.dirty = true;
+        return count;
+    }
+    /** Load all patterns currently held in memory */
+    async loadPatterns() {
+        this.ensureInitialized();
+        return Array.from(this.patterns.values());
+    }
+    /** Return the number of stored patterns */
+    async getPatternCount() {
+        this.ensureInitialized();
+        return this.patterns.size;
+    }
+    // ===== LoRA operations =====
+    /** Save or update a LoRA adapter record */
+    async saveLoraAdapter(record) {
+        this.ensureInitialized();
+        this.loraAdapters.set(record.id, { ...record });
+        this.dirty = true;
+    }
+    /** Load all LoRA adapter records */
+    async loadLoraAdapters() {
+        this.ensureInitialized();
+        return Array.from(this.loraAdapters.values());
+    }
+    /** Delete a LoRA adapter by ID */
+    async deleteLoraAdapter(id) {
+        this.ensureInitialized();
+        const existed = this.loraAdapters.delete(id);
+        if (existed)
+            this.dirty = true;
+        return existed;
+    }
+    // ===== EWC operations =====
+    /** Save EWC state (replaces any existing state) */
+    async saveEwcState(record) {
+        this.ensureInitialized();
+        this.ewcState = { ...record };
+        this.dirty = true;
+    }
+    /** Load the EWC state, or null if none has been stored */
+    async loadEwcState() {
+        this.ensureInitialized();
+        return this.ewcState ? { ...this.ewcState } : null;
+    }
+    // ===== Trajectory operations =====
+    /** Append a trajectory record (append-only, never overwritten) */
+    async appendTrajectory(record) {
+        this.ensureInitialized();
+        this.trajectories.push({ ...record });
+        this.dirty = true;
+    }
+    /**
+     * Return stored trajectories, newest first.
+     * @param limit Maximum number to return (default: all)
+     */
+    async getTrajectories(limit) {
+        this.ensureInitialized();
+        const sorted = [...this.trajectories].reverse();
+        return limit !== undefined ? sorted.slice(0, limit) : sorted;
+    }
+    /** Return the number of stored trajectories */
+    async getTrajectoryCount() {
+        this.ensureInitialized();
+        return this.trajectories.length;
+    }
+    // ===== Lifecycle =====
+    /**
+     * Flush all in-memory state to disk. The entire file is rewritten
+     * to ensure consistency (patterns may have been updated in-place).
+     */
+    async persist() {
+        if (!this.dirty)
+            return;
+        ensureDirectory(this.config.storePath);
+        const lines = [MAGIC_HEADER];
+        // Patterns
+        for (const pattern of this.patterns.values()) {
+            lines.push(JSON.stringify({ type: 'pattern', data: pattern }));
+        }
+        // LoRA adapters
+        for (const lora of this.loraAdapters.values()) {
+            lines.push(JSON.stringify({ type: 'lora', data: lora }));
+        }
+        // EWC state
+        if (this.ewcState) {
+            lines.push(JSON.stringify({ type: 'ewc', data: this.ewcState }));
+        }
+        // Trajectories
+        for (const traj of this.trajectories) {
+            lines.push(JSON.stringify({ type: 'trajectory', data: traj }));
+        }
+        const content = lines.join('\n') + '\n';
+        const tmpPath = this.config.storePath + '.tmp';
+        await fs.promises.writeFile(tmpPath, content, 'utf-8');
+        await fs.promises.rename(tmpPath, this.config.storePath);
+        this.dirty = false;
+        this.log(`Persisted: ${this.patterns.size} patterns, ${this.loraAdapters.size} LoRA, ${this.trajectories.length} trajectories`);
+    }
+    /** Persist and release resources */
+    async close() {
+        if (this.autoPersistTimer) {
+            clearInterval(this.autoPersistTimer);
+            this.autoPersistTimer = null;
+        }
+        if (this.dirty) {
+            await this.persist();
+        }
+        this.initialized = false;
+        this.log('Store closed');
+    }
+    // ===== Stats =====
+    /** Return summary statistics about the store */
+    async getStats() {
+        this.ensureInitialized();
+        let fileSizeBytes = 0;
+        try {
+            const stat = await fs.promises.stat(this.config.storePath);
+            fileSizeBytes = stat.size;
+        }
+        catch {
+            // File may not exist yet if nothing has been persisted
+        }
+        return {
+            patterns: this.patterns.size,
+            loraAdapters: this.loraAdapters.size,
+            trajectories: this.trajectories.length,
+            hasEwcState: this.ewcState !== null,
+            fileSizeBytes,
+        };
+    }
+    // ===== Private =====
+    async loadFromDisk() {
+        let content;
+        try {
+            content = await fs.promises.readFile(this.config.storePath, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        const lines = content.split('\n').filter((l) => l.trim().length > 0);
+        if (lines.length === 0)
+            return;
+        // Verify magic header
+        if (lines[0] !== MAGIC_HEADER) {
+            this.log(`Warning: invalid magic header "${lines[0]}", expected "${MAGIC_HEADER}"`);
+            return;
+        }
+        let parsed = 0;
+        let errors = 0;
+        for (let i = 1; i < lines.length; i++) {
+            try {
+                const record = JSON.parse(lines[i]);
+                this.applyRecord(record);
+                parsed++;
+            }
+            catch {
+                errors++;
+                this.log(`Warning: failed to parse line ${i + 1}`);
+            }
+        }
+        this.log(`Loaded from disk: ${parsed} records, ${errors} errors`);
+    }
+    applyRecord(record) {
+        switch (record.type) {
+            case 'pattern': {
+                const p = record.data;
+                this.patterns.set(p.id, p);
+                break;
+            }
+            case 'lora': {
+                const l = record.data;
+                this.loraAdapters.set(l.id, l);
+                break;
+            }
+            case 'ewc': {
+                this.ewcState = record.data;
+                break;
+            }
+            case 'trajectory': {
+                this.trajectories.push(record.data);
+                break;
+            }
+            default:
+                this.log(`Warning: unknown record type "${record.type}"`);
+        }
+    }
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('RvfLearningStore has not been initialized. Call initialize() first.');
+        }
+    }
+    log(message) {
+        if (this.config.verbose) {
+            // eslint-disable-next-line no-console
+            console.log(`[RvfLearningStore] ${message}`);
+        }
+    }
+}
+//# sourceMappingURL=rvf-learning-store.js.map

package/v3/@claude-flow/memory/dist/rvf-migration.d.ts

@@ -0,0 +1,45 @@
+/** Options for controlling the migration process. */
+export interface RvfMigrationOptions {
+    verbose?: boolean;
+    /** Entries per batch (default 500). */
+    batchSize?: number;
+    /** Embedding dimensions for target RVF file (default 1536). */
+    dimensions?: number;
+    onProgress?: (progress: {
+        current: number;
+        total: number;
+        phase: string;
+    }) => void;
+}
+/** Result returned after a migration completes. */
+export interface RvfMigrationResult {
+    success: boolean;
+    entriesMigrated: number;
+    sourceFormat: string;
+    targetFormat: string;
+    durationMs: number;
+    errors: string[];
+}
+/**
+ * Bidirectional migration utility between RVF and legacy memory formats.
+ *
+ * All methods are static — no instantiation required.
+ */
+export declare class RvfMigrator {
+    /** Migrate a JSON memory file to RVF format. */
+    static fromJsonFile(jsonPath: string, rvfPath: string, options?: RvfMigrationOptions): Promise<RvfMigrationResult>;
+    /** Migrate a SQLite (better-sqlite3 / sql.js) database to RVF. */
+    static fromSqlite(dbPath: string, rvfPath: string, options?: RvfMigrationOptions): Promise<RvfMigrationResult>;
+    /** Export an RVF file back to a JSON array (backward compatibility). */
+    static toJsonFile(rvfPath: string, jsonPath: string): Promise<RvfMigrationResult>;
+    /**
+     * Detect file format by magic bytes.
+     * - RVF\0 (0x52 0x56 0x46 0x00) -> 'rvf'
+     * - SQLi  (0x53 0x51 0x4C 0x69) -> 'sqlite'
+     * - Leading [ or {              -> 'json'
+     */
+    static detectFormat(filePath: string): Promise<'rvf' | 'json' | 'sqlite' | 'unknown'>;
+    /** Auto-detect source format and migrate to RVF. */
+    static autoMigrate(sourcePath: string, targetRvfPath: string, options?: RvfMigrationOptions): Promise<RvfMigrationResult>;
+}
+//# sourceMappingURL=rvf-migration.d.ts.map

package/v3/@claude-flow/memory/dist/rvf-migration.js

@@ -0,0 +1,234 @@
+/**
+ * RVF Migration Utility — bidirectional migration between RVF and legacy
+ * formats (JSON files, sql.js / better-sqlite3 databases).
+ * @module @claude-flow/memory/rvf-migration
+ */
+import { readFile, writeFile, rename, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { RvfBackend } from './rvf-backend.js';
+import { generateMemoryId } from './types.js';
+// -- Internal helpers -------------------------------------------------------
+function fillDefaults(raw) {
+    const now = Date.now();
+    return {
+        id: raw.id ?? generateMemoryId(),
+        key: raw.key ?? '',
+        content: raw.content ?? '',
+        type: raw.type ?? 'semantic',
+        namespace: raw.namespace ?? 'default',
+        tags: raw.tags ?? [],
+        metadata: raw.metadata ?? {},
+        ownerId: raw.ownerId,
+        accessLevel: raw.accessLevel ?? 'private',
+        createdAt: raw.createdAt ?? now,
+        updatedAt: raw.updatedAt ?? now,
+        expiresAt: raw.expiresAt,
+        version: raw.version ?? 1,
+        references: raw.references ?? [],
+        accessCount: raw.accessCount ?? 0,
+        lastAccessedAt: raw.lastAccessedAt ?? now,
+        embedding: deserializeEmbedding(raw.embedding),
+    };
+}
+function deserializeEmbedding(value) {
+    if (!value)
+        return undefined;
+    if (value instanceof Float32Array)
+        return value;
+    if (value instanceof Buffer || value instanceof Uint8Array) {
+        if (value.byteLength === 0)
+            return undefined;
+        const out = new Float32Array(value.byteLength / 4);
+        const view = new DataView(value.buffer, value.byteOffset, value.byteLength);
+        for (let i = 0; i < out.length; i++)
+            out[i] = view.getFloat32(i * 4, true);
+        return out;
+    }
+    if (Array.isArray(value))
+        return new Float32Array(value);
+    return undefined;
+}
+function serializeForJson(entry) {
+    return { ...entry, embedding: entry.embedding ? Array.from(entry.embedding) : undefined };
+}
+function validateMigrationPath(p) {
+    if (!p || typeof p !== 'string')
+        throw new Error('Path must be a non-empty string');
+    if (p.includes('\0'))
+        throw new Error('Path contains null bytes');
+}
+async function ensureDir(filePath) {
+    validateMigrationPath(filePath);
+    const dir = dirname(resolve(filePath));
+    if (!existsSync(dir))
+        await mkdir(dir, { recursive: true });
+}
+async function atomicWrite(targetPath, data) {
+    validateMigrationPath(targetPath);
+    const abs = resolve(targetPath);
+    const tmp = abs + '.tmp.' + Date.now();
+    await ensureDir(abs);
+    await writeFile(tmp, data, typeof data === 'string' ? 'utf-8' : undefined);
+    await rename(tmp, abs);
+}
+function mkResult(success, entriesMigrated, sourceFormat, targetFormat, startMs, errors) {
+    return { success, entriesMigrated, sourceFormat, targetFormat, durationMs: Date.now() - startMs, errors };
+}
+function normalizeSqliteRow(row) {
+    const out = { ...row };
+    for (const col of ['tags', 'metadata', 'references']) {
+        if (typeof out[col] === 'string') {
+            try {
+                out[col] = JSON.parse(out[col]);
+            }
+            catch {
+                out[col] = col === 'metadata' ? {} : [];
+            }
+        }
+    }
+    return out;
+}
+async function readSqliteRows(dbPath) {
+    // Use sql.js (WASM) for SQLite reading
+    try {
+        const initSqlJs = (await import('sql.js')).default;
+        const SQL = await initSqlJs();
+        const fs = await import('node:fs');
+        const buf = fs.readFileSync(dbPath);
+        const db = new SQL.Database(buf);
+        return { exec: (sql) => db.exec(sql), close: () => db.close() };
+    }
+    catch {
+        throw new Error('Cannot read SQLite: install sql.js');
+    }
+}
+// -- Batch migration helper -------------------------------------------------
+async function migrateBatches(items, rvfPath, options, normalize) {
+    const batchSize = options.batchSize ?? 500;
+    const dimensions = options.dimensions ?? 1536;
+    const backend = new RvfBackend({ databasePath: rvfPath, dimensions, verbose: options.verbose });
+    await backend.initialize();
+    let migrated = 0;
+    const errors = [];
+    try {
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            const entries = [];
+            for (const item of batch) {
+                try {
+                    entries.push(fillDefaults(normalize ? normalize(item) : item));
+                }
+                catch (e) {
+                    errors.push(`Entry ${item.id ?? i}: ${e.message}`);
+                }
+            }
+            if (entries.length > 0) {
+                await backend.bulkInsert(entries);
+                migrated += entries.length;
+            }
+            options.onProgress?.({ current: Math.min(i + batchSize, items.length), total: items.length, phase: 'migrating' });
+        }
+    }
+    finally {
+        await backend.shutdown();
+    }
+    return { migrated, errors };
+}
+/**
+ * Bidirectional migration utility between RVF and legacy memory formats.
+ *
+ * All methods are static — no instantiation required.
+ */
+export class RvfMigrator {
+    /** Migrate a JSON memory file to RVF format. */
+    static async fromJsonFile(jsonPath, rvfPath, options = {}) {
+        const start = Date.now();
+        const raw = await readFile(jsonPath, 'utf-8');
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (e) {
+            return mkResult(false, 0, 'json', 'rvf', start, [`Invalid JSON: ${e.message}`]);
+        }
+        const items = Array.isArray(parsed) ? parsed : [parsed];
+        const { migrated, errors } = await migrateBatches(items, rvfPath, options);
+        if (options.verbose)
+            console.log(`[RvfMigrator] Migrated ${migrated} entries from JSON to RVF`);
+        return mkResult(errors.length === 0, migrated, 'json', 'rvf', start, errors);
+    }
+    /** Migrate a SQLite (better-sqlite3 / sql.js) database to RVF. */
+    static async fromSqlite(dbPath, rvfPath, options = {}) {
+        const start = Date.now();
+        let rows;
+        try {
+            rows = await readSqliteRows(dbPath);
+        }
+        catch (e) {
+            return mkResult(false, 0, 'sqlite', 'rvf', start, [e.message]);
+        }
+        options.onProgress?.({ current: 0, total: rows.length, phase: 'reading' });
+        const { migrated, errors } = await migrateBatches(rows, rvfPath, options, normalizeSqliteRow);
+        if (options.verbose)
+            console.log(`[RvfMigrator] Migrated ${migrated} entries from SQLite to RVF`);
+        return mkResult(errors.length === 0, migrated, 'sqlite', 'rvf', start, errors);
+    }
+    /** Export an RVF file back to a JSON array (backward compatibility). */
+    static async toJsonFile(rvfPath, jsonPath) {
+        const start = Date.now();
+        const backend = new RvfBackend({ databasePath: rvfPath });
+        await backend.initialize();
+        let entries;
+        try {
+            entries = await backend.query({ type: 'hybrid', limit: Number.MAX_SAFE_INTEGER });
+        }
+        finally {
+            await backend.shutdown();
+        }
+        const warnings = [];
+        if (entries.length === 0)
+            warnings.push('Source RVF file contained no entries');
+        await atomicWrite(jsonPath, JSON.stringify(entries.map(serializeForJson), null, 2));
+        return mkResult(true, entries.length, 'rvf', 'json', start, warnings);
+    }
+    /**
+     * Detect file format by magic bytes.
+     * - RVF\0 (0x52 0x56 0x46 0x00) -> 'rvf'
+     * - SQLi  (0x53 0x51 0x4C 0x69) -> 'sqlite'
+     * - Leading [ or {              -> 'json'
+     */
+    static async detectFormat(filePath) {
+        if (!existsSync(filePath))
+            return 'unknown';
+        const fd = await import('node:fs').then(m => m.promises.open(filePath, 'r'));
+        try {
+            const buf = Buffer.alloc(16);
+            await fd.read(buf, 0, 16, 0);
+            if (buf[0] === 0x52 && buf[1] === 0x56 && buf[2] === 0x46 && buf[3] === 0x00)
+                return 'rvf';
+            if (buf[0] === 0x53 && buf[1] === 0x51 && buf[2] === 0x4C && buf[3] === 0x69)
+                return 'sqlite';
+            const head = buf.toString('utf-8').trimStart();
+            if (head.startsWith('[') || head.startsWith('{'))
+                return 'json';
+            return 'unknown';
+        }
+        finally {
+            await fd.close();
+        }
+    }
+    /** Auto-detect source format and migrate to RVF. */
+    static async autoMigrate(sourcePath, targetRvfPath, options = {}) {
+        const format = await RvfMigrator.detectFormat(sourcePath);
+        if (options.verbose)
+            console.log(`[RvfMigrator] Detected source format: ${format}`);
+        switch (format) {
+            case 'json': return RvfMigrator.fromJsonFile(sourcePath, targetRvfPath, options);
+            case 'sqlite': return RvfMigrator.fromSqlite(sourcePath, targetRvfPath, options);
+            case 'rvf': return { success: true, entriesMigrated: 0, sourceFormat: 'rvf', targetFormat: 'rvf', durationMs: 0, errors: [] };
+            default: return { success: false, entriesMigrated: 0, sourceFormat: 'unknown', targetFormat: 'rvf', durationMs: 0, errors: [`Unrecognized format: ${sourcePath}`] };
+        }
+    }
+}
+//# sourceMappingURL=rvf-migration.js.map

package/v3/@claude-flow/memory/dist/sqlite-backend.d.ts

@@ -0,0 +1,121 @@
+/**
+ * SQLite Memory Backend
+ *
+ * Provides structured storage for memory entries using SQLite.
+ * Optimized for ACID transactions, exact matches, and complex queries.
+ * Part of ADR-009: Hybrid Memory Backend (SQLite + AgentDB)
+ *
+ * @module v3/memory/sqlite-backend
+ */
+import { EventEmitter } from 'node:events';
+import { IMemoryBackend, MemoryEntry, MemoryEntryUpdate, MemoryQuery, SearchOptions, SearchResult, BackendStats, HealthCheckResult, EmbeddingGenerator } from './types.js';
+/**
+ * Configuration for SQLite Backend
+ */
+export interface SQLiteBackendConfig {
+    /** Path to SQLite database file (:memory: for in-memory) */
+    databasePath: string;
+    /** Enable WAL mode for better concurrency */
+    walMode: boolean;
+    /** Enable query optimization */
+    optimize: boolean;
+    /** Default namespace */
+    defaultNamespace: string;
+    /** Embedding generator (for compatibility with hybrid mode) */
+    embeddingGenerator?: EmbeddingGenerator;
+    /** Maximum entries before auto-cleanup */
+    maxEntries: number;
+    /** Enable verbose logging */
+    verbose: boolean;
+}
+/**
+ * SQLite Backend for Structured Memory Storage
+ *
+ * Provides:
+ * - ACID transactions for data consistency
+ * - Efficient indexing for exact matches and prefix queries
+ * - Full-text search capabilities
+ * - Complex SQL queries with joins and aggregations
+ * - Persistent storage with WAL mode
+ */
+export declare class SQLiteBackend extends EventEmitter implements IMemoryBackend {
+    private config;
+    private db;
+    private initialized;
+    private stats;
+    constructor(config?: Partial<SQLiteBackendConfig>);
+    /**
+     * Initialize the SQLite backend
+     */
+    initialize(): Promise<void>;
+    /**
+     * Shutdown the backend
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Store a memory entry
+     */
+    store(entry: MemoryEntry): Promise<void>;
+    /**
+     * Get a memory entry by ID
+     */
+    get(id: string): Promise<MemoryEntry | null>;
+    /**
+     * Get a memory entry by key within a namespace
+     */
+    getByKey(namespace: string, key: string): Promise<MemoryEntry | null>;
+    /**
+     * Update a memory entry
+     */
+    update(id: string, update: MemoryEntryUpdate): Promise<MemoryEntry | null>;
+    /**
+     * Delete a memory entry
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Query memory entries with filters
+     */
+    query(query: MemoryQuery): Promise<MemoryEntry[]>;
+    /**
+     * Semantic vector search (not optimized for SQLite, returns empty)
+     * Use HybridBackend for semantic search with AgentDB
+     */
+    search(embedding: Float32Array, options: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Bulk insert entries
+     */
+    bulkInsert(entries: MemoryEntry[]): Promise<void>;
+    /**
+     * Bulk delete entries
+     */
+    bulkDelete(ids: string[]): Promise<number>;
+    /**
+     * Get entry count
+     */
+    count(namespace?: string): Promise<number>;
+    /**
+     * List all namespaces
+     */
+    listNamespaces(): Promise<string[]>;
+    /**
+     * Clear all entries in a namespace
+     */
+    clearNamespace(namespace: string): Promise<number>;
+    /**
+     * Get backend statistics
+     */
+    getStats(): Promise<BackendStats>;
+    /**
+     * Perform health check
+     */
+    healthCheck(): Promise<HealthCheckResult>;
+    private ensureInitialized;
+    private createSchema;
+    private rowToEntry;
+    /**
+     * Synchronous store for use in transactions
+     */
+    private storeSync;
+}
+export default SQLiteBackend;
+//# sourceMappingURL=sqlite-backend.d.ts.map