moflo 4.8.16 → 4.8.19

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

@@ -1,295 +0,0 @@
-/**
- * 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/src/@claude-flow/memory/dist/rvf-migration.d.ts

@@ -1,45 +0,0 @@
-/** 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/src/@claude-flow/memory/dist/rvf-migration.js

@@ -1,234 +0,0 @@
-/**
- * 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/src/@claude-flow/memory/dist/sqlite-backend.d.ts

@@ -1,121 +0,0 @@
-/**
- * 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