@monoes/memory 1.0.2 → 1.0.4

package/dist/hybrid-backend.js

@@ -1,805 +0,0 @@
-/**
- * HybridBackend - Combines SQLite (structured queries) + LanceDB (vector search)
- *
- * Per ADR-009: "HybridBackend (SQLite + LanceDB) as default"
- * - SQLite for: Structured queries, ACID transactions, exact matches
- * - LanceDB for: Semantic search, vector similarity, RAG
- *
- * @module v1/memory/hybrid-backend
- */
-import { EventEmitter } from 'node:events';
-import { SQLiteBackend } from './sqlite-backend.js';
-import { LanceDBBackend } from './lancedb-backend.js';
-import { MemoryGraph } from './memory-graph.js';
-/**
- * Default configuration
- */
-const DEFAULT_CONFIG = {
-    sqlite: {},
-    lancedb: {},
-    semanticBackend: 'lancedb',
-    defaultNamespace: 'default',
-    embeddingGenerator: undefined,
-    routingStrategy: 'auto',
-    dualWrite: true,
-    semanticThreshold: 0.7,
-    hybridMaxResults: 100,
-    filterInjection: false,
-    memoragRewriter: undefined,
-};
-/**
- * Structural prompt-injection patterns for filtering externally-sourced content.
- * Source: arXiv:2302.12173, arXiv:2310.12815 — indirect prompt injection in RAG pipelines.
- */
-const INJECTION_PATTERNS = [
-    /ignore\s+(all\s+)?previous\s+instructions?/i,
-    /you\s+are\s+now\s+(a|an)\s+/i,
-    /system\s*prompt\s*[:=]/i,
-    /\[\s*system\s*\]/i,
-    /\bforget\s+(your\s+)?(previous\s+)?instructions?\b/i,
-    /act\s+as\s+(if\s+you\s+(are|were)\s+)?/i,
-    /jailbreak/i,
-    /\bDAN\b/,
-    /<\s*\/?system\s*>/i,
-];
-/**
- * HybridBackend Implementation
- *
- * Intelligently routes queries between SQLite and LanceDB:
- * - Exact matches, prefix queries → SQLite
- * - Semantic search, similarity → LanceDB
- * - Complex hybrid queries → Both backends with intelligent merging
- */
-export class HybridBackend extends EventEmitter {
-    sqlite; // SQLiteBackend normally; same as semantic when lancedb solo
-    semantic; // LanceDBBackend
-    config;
-    initialized = false;
-    /** Lazy MemoryGraph for HippoRAG PPR re-ranking */
-    memoryGraph = null;
-    // Performance tracking
-    stats = {
-        sqliteQueries: 0,
-        semanticQueries: 0,
-        hybridQueries: 0,
-        totalQueryTime: 0,
-    };
-    constructor(config = {}) {
-        super();
-        this.config = { ...DEFAULT_CONFIG, ...config };
-        // Initialize semantic backend (LanceDB)
-        if (this.config.semanticBackend === 'lancedb') {
-            // Solo LanceDB mode: one backend handles all queries (structured + vector).
-            // Both this.sqlite and this.semantic point to the same instance so all
-            // routing paths (exact/prefix/tag/semantic) transparently use LanceDB.
-            // dualWrite forced off to prevent double-writes to the same instance.
-            const ldb = new LanceDBBackend({
-                ...this.config.lancedb,
-                namespace: this.config.defaultNamespace,
-                embeddingGenerator: this.config.embeddingGenerator,
-            });
-            this.semantic = ldb;
-            this.sqlite = ldb;
-            this.config.dualWrite = false;
-        }
-        else {
-            this.sqlite = new SQLiteBackend({
-                ...this.config.sqlite,
-                defaultNamespace: this.config.defaultNamespace,
-                embeddingGenerator: this.config.embeddingGenerator,
-            });
-            this.semantic = new LanceDBBackend({
-                ...this.config.lancedb,
-                namespace: this.config.defaultNamespace,
-                embeddingGenerator: this.config.embeddingGenerator,
-            });
-        }
-        // Forward events (skip duplicate wiring in solo mode)
-        const em = (b) => b;
-        em(this.sqlite).on?.('entry:stored', (d) => this.emit('sqlite:stored', d));
-        em(this.sqlite).on?.('entry:updated', (d) => this.emit('sqlite:updated', d));
-        em(this.sqlite).on?.('entry:deleted', (d) => this.emit('sqlite:deleted', d));
-        if (this.semantic !== this.sqlite) {
-            em(this.semantic).on?.('entry:stored', (d) => this.emit('semantic:stored', d));
-            em(this.semantic).on?.('entry:updated', (d) => this.emit('semantic:updated', d));
-            em(this.semantic).on?.('entry:deleted', (d) => this.emit('semantic:deleted', d));
-            em(this.semantic).on?.('cache:hit', (d) => this.emit('cache:hit', d));
-            em(this.semantic).on?.('cache:miss', (d) => this.emit('cache:miss', d));
-        }
-    }
-    /**
-     * Initialize both backends
-     */
-    async initialize() {
-        if (this.initialized)
-            return;
-        const inits = this.semantic === this.sqlite
-            ? [this.semantic.initialize()]
-            : [this.sqlite.initialize(), this.semantic.initialize()];
-        await Promise.all(inits);
-        this.initialized = true;
-        this.emit('initialized');
-    }
-    /**
-     * Shutdown both backends
-     */
-    async shutdown() {
-        if (!this.initialized)
-            return;
-        const shutdowns = this.semantic === this.sqlite
-            ? [this.semantic.shutdown()]
-            : [this.sqlite.shutdown(), this.semantic.shutdown()];
-        await Promise.all(shutdowns);
-        this.initialized = false;
-        this.emit('shutdown');
-    }
-    /**
-     * Store in both backends (dual-write for consistency).
-     *
-     * A-MEM auto-linking: after writing, HNSW-searches for the top-3 most similar
-     * existing entries and adds bidirectional `references` edges between them and
-     * the new entry.  Only runs when an `embeddingGenerator` is configured.
-     * Source: arXiv:2409.11987 (A-MEM — Zettelkasten-style agent memory)
-     */
-    async store(entry) {
-        if (this.config.dualWrite) {
-            // Write to both backends in parallel
-            await Promise.all([this.sqlite.store(entry), this.semantic.store(entry)]);
-        }
-        else {
-            // Write to primary backend only
-            await this.semantic.store(entry);
-        }
-        this.emit('entry:stored', { id: entry.id });
-        // A-MEM: auto-link to top-3 semantic neighbors (non-blocking, best-effort)
-        if (typeof this.config.embeddingGenerator === 'function' && entry.content) {
-            this.aMemAutoLink(entry).catch(() => {
-                // Linking is best-effort; storage already succeeded
-            });
-        }
-    }
-    /**
-     * A-MEM bidirectional reference linking.
-     * Finds the top-3 semantically similar existing entries and creates
-     * `references` edges in both directions.
-     */
-    async aMemAutoLink(newEntry) {
-        try {
-            const embedding = await this.config.embeddingGenerator(newEntry.content);
-            const neighbors = await this.semantic.search(embedding, {
-                k: 4, // fetch 4 to exclude self
-                threshold: 0.75,
-            });
-            const topNeighbors = neighbors
-                .filter(r => r.entry.id !== newEntry.id)
-                .slice(0, 3);
-            if (topNeighbors.length === 0)
-                return;
-            const neighborIds = topNeighbors.map(r => r.entry.id);
-            // Update new entry to reference neighbors
-            const newRefs = [...new Set([...(newEntry.references ?? []), ...neighborIds])];
-            await this.update(newEntry.id, { references: newRefs });
-            // Update each neighbor to back-reference the new entry
-            await Promise.all(topNeighbors.map(async ({ entry: neighbor }) => {
-                const backRefs = [...new Set([...(neighbor.references ?? []), newEntry.id])];
-                await this.update(neighbor.id, { references: backRefs });
-            }));
-            this.emit('amem:linked', { id: newEntry.id, linkedTo: neighborIds });
-        }
-        catch {
-            // Linking is best-effort
-        }
-    }
-    /**
-     * Get from semantic backend.
-     *
-     * Collaborative memory promotion: when `agentId` is supplied, also notifies
-     * the SQLite backend so it can track the read and promote the entry's
-     * AccessLevel to 'team' once 3+ distinct agents have accessed it.
-     * Source: newinnovation.md §2.7 — memory access-level promotion.
-     */
-    async get(id, agentId) {
-        const entry = await this.semantic.get(id);
-        // Track the read in SQLite for collaborative promotion (best-effort, non-blocking).
-        // Skipped in solo-lancedb mode since this.sqlite === this.semantic (already fetched above).
-        if (agentId && entry && this.semantic !== this.sqlite) {
-            this.sqlite.get(id, agentId).catch(() => { });
-        }
-        return entry;
-    }
-    /**
-     * Get by key (SQLite optimized for exact matches)
-     */
-    async getByKey(namespace, key) {
-        return this.sqlite.getByKey(namespace, key);
-    }
-    /**
-     * Update in both backends
-     */
-    async update(id, update) {
-        if (this.config.dualWrite) {
-            // Update both backends
-            const [sqliteResult, semanticResult] = await Promise.all([
-                this.sqlite.update(id, update),
-                this.semantic.update(id, update),
-            ]);
-            return semanticResult || sqliteResult;
-        }
-        else {
-            return this.semantic.update(id, update);
-        }
-    }
-    /**
-     * Delete from both backends
-     */
-    async delete(id) {
-        if (this.config.dualWrite) {
-            const [sqliteResult, semanticResult] = await Promise.all([
-                this.sqlite.delete(id),
-                this.semantic.delete(id),
-            ]);
-            return sqliteResult || semanticResult;
-        }
-        else {
-            return this.semantic.delete(id);
-        }
-    }
-    /**
-     * Query routing — semantic goes to LanceDB, structured to SQLite
-     */
-    async query(query) {
-        const startTime = performance.now();
-        let results;
-        // Route based on query type
-        switch (query.type) {
-            case 'exact':
-                // SQLite optimized for exact matches
-                this.stats.sqliteQueries++;
-                results = await this.sqlite.query(query);
-                break;
-            case 'prefix':
-                // SQLite optimized for prefix queries
-                this.stats.sqliteQueries++;
-                results = await this.sqlite.query(query);
-                break;
-            case 'tag':
-                // Both can handle tags, use SQLite for structured filtering
-                this.stats.sqliteQueries++;
-                results = await this.sqlite.query(query);
-                break;
-            case 'semantic':
-                // LanceDB handles semantic search
-                this.stats.semanticQueries++;
-                results = await this.semantic.query(query);
-                break;
-            case 'hybrid':
-                // Use hybrid query combining both backends
-                this.stats.hybridQueries++;
-                results = await this.queryHybridInternal(query);
-                break;
-            default:
-                // Auto-routing based on query properties
-                results = await this.autoRoute(query);
-        }
-        const duration = performance.now() - startTime;
-        this.stats.totalQueryTime += duration;
-        this.emit('query:completed', { type: query.type, duration, count: results.length });
-        return results;
-    }
-    /**
-     * Structured queries (SQL)
-     * Routes to SQLite for optimal performance
-     */
-    async queryStructured(query) {
-        this.stats.sqliteQueries++;
-        const memoryQuery = {
-            type: query.key ? 'exact' : query.keyPrefix ? 'prefix' : 'hybrid',
-            key: query.key,
-            keyPrefix: query.keyPrefix,
-            namespace: query.namespace,
-            ownerId: query.ownerId,
-            memoryType: query.type,
-            createdAfter: query.createdAfter,
-            createdBefore: query.createdBefore,
-            updatedAfter: query.updatedAfter,
-            updatedBefore: query.updatedBefore,
-            limit: query.limit || 100,
-            offset: query.offset || 0,
-        };
-        return this.sqlite.query(memoryQuery);
-    }
-    /**
-     * Apply injection filtering and structured field filters to a set of entries.
-     * Used by the MemoRAG path (RRF-fused results) and as a shared post-processing step.
-     */
-    postProcessSemanticResults(entries, query) {
-        let result = entries;
-        if (this.config.filterInjection) {
-            result = result.filter(entry => {
-                const content = entry.content ?? '';
-                if (INJECTION_PATTERNS.some(rx => rx.test(content))) {
-                    this.emit('injection:blocked', { id: entry.id, namespace: entry.namespace });
-                    return false;
-                }
-                return true;
-            });
-        }
-        if (query.filters) {
-            const f = query.filters;
-            if (f.tags && Array.isArray(f.tags)) {
-                const requiredTags = f.tags;
-                result = result.filter(e => requiredTags.every(t => e.tags.includes(t)));
-            }
-            if (f.namespace && typeof f.namespace === 'string') {
-                result = result.filter(e => e.namespace === f.namespace);
-            }
-            if (f.type && typeof f.type === 'string' && f.type !== 'semantic') {
-                result = result.filter(e => e.type === f.type);
-            }
-        }
-        return result.slice(0, query.k || 10);
-    }
-    /**
-     * Reciprocal Rank Fusion — merge multiple ranked result lists.
-     * Score for entry i in list j: 1 / (k + rank_j(i))  where k=60 (standard).
-     * Source: Cormack et al., "Reciprocal Rank Fusion outperforms Condorcet and individual
-     * Rank Learning Methods" (SIGIR 2009). Used by MemoRAG sub-query fusion.
-     */
-    rrfFuse(rankedLists, k = 60) {
-        const scores = new Map();
-        const byId = new Map();
-        for (const list of rankedLists) {
-            for (let rank = 0; rank < list.length; rank++) {
-                const entry = list[rank];
-                byId.set(entry.id, entry);
-                scores.set(entry.id, (scores.get(entry.id) ?? 0) + 1 / (k + rank + 1));
-            }
-        }
-        return [...byId.keys()]
-            .sort((a, b) => (scores.get(b) ?? 0) - (scores.get(a) ?? 0))
-            .map(id => byId.get(id));
-    }
-    /**
-     * Semantic queries (vector)
-     * Routes to semantic backend for ANN vector search.
-     *
-     * MemoRAG query rewriting (arXiv:2409.05591): when `memoragRewriter` is configured
-     * and `query.content` is present, generates 2-3 reformulated sub-queries, embeds
-     * each, searches HNSW independently, then fuses with Reciprocal Rank Fusion (RRF)
-     * before HippoRAG PPR re-ranking.
-     */
-    async querySemantic(query) {
-        this.stats.semanticQueries++;
-        let searchResults = [];
-        // MemoRAG: expand the query into multiple sub-queries for richer recall
-        let memoragUsed = false;
-        if (query.content && typeof this.config.memoragRewriter === 'function') {
-            try {
-                const subQueries = await this.config.memoragRewriter(query.content);
-                if (subQueries.length > 0) {
-                    // Embed all sub-queries and search in parallel
-                    const subResults = await Promise.all(subQueries.map(async (sq) => {
-                        if (!this.config.embeddingGenerator)
-                            return [];
-                        const sqEmbedding = await this.config.embeddingGenerator(sq);
-                        const results = await this.semantic.search(sqEmbedding, {
-                            k: (query.k || 10) * 2,
-                            threshold: query.threshold || this.config.semanticThreshold,
-                            filters: query.filters,
-                        });
-                        return results.map(r => r.entry);
-                    }));
-                    this.emit('memorag:rewritten', { original: query.content, subQueries, count: subResults.flat().length });
-                    // RRF-fuse the sub-query results; assign to searchResults to fall through to PPR/GraphRAG
-                    const fused = this.rrfFuse(subResults);
-                    searchResults = fused.map(entry => ({ entry, score: 1.0, distance: 0 }));
-                    memoragUsed = true;
-                }
-            }
-            catch {
-                // Rewriter failed — fall through to standard path
-            }
-        }
-        if (!memoragUsed) {
-            let embedding = query.embedding;
-            // Generate embedding if content provided
-            if (!embedding && query.content && this.config.embeddingGenerator) {
-                embedding = await this.config.embeddingGenerator(query.content);
-            }
-            if (!embedding) {
-                throw new Error('SemanticQuery requires either content or embedding');
-            }
-            searchResults = await this.semantic.search(embedding, {
-                k: (query.k || 10) * 2, // Over-fetch to account for post-filtering
-                threshold: query.threshold || this.config.semanticThreshold,
-                filters: query.filters,
-            });
-        }
-        // HippoRAG PPR re-ranking: expand one hop through MemoryEntry.references
-        // Source: https://arxiv.org/abs/2405.14831
-        let entries;
-        if (searchResults.length > 0) {
-            if (!this.memoryGraph) {
-                this.memoryGraph = new MemoryGraph();
-                // Seed graph with reference edges from search results
-                for (const r of searchResults) {
-                    this.memoryGraph.addNode(r.entry);
-                    for (const refId of (r.entry.references ?? [])) {
-                        this.memoryGraph.addEdge(r.entry.id, refId, 'reference', 1.0);
-                    }
-                }
-            }
-            else {
-                for (const r of searchResults) {
-                    this.memoryGraph.addNode(r.entry);
-                    for (const refId of (r.entry.references ?? [])) {
-                        this.memoryGraph.addEdge(r.entry.id, refId, 'reference', 1.0);
-                    }
-                }
-            }
-            // GraphRAG: compute community summaries before PPR so communities are populated.
-            // Community summaries are prepended to each entry's metadata so downstream callers
-            // can use global thematic context alongside local vector similarity.
-            // Source: https://arxiv.org/abs/2404.16130 (Microsoft GraphRAG)
-            const communitySummaries = this.memoryGraph.getCommunitySummaries(5);
-            // Build a nodeId → community summary lookup for O(1) annotation
-            const nodeToSummary = new Map();
-            for (const summary of communitySummaries) {
-                for (const nodeId of summary.topNodeIds) {
-                    nodeToSummary.set(nodeId, {
-                        communityId: summary.communityId,
-                        nodeCount: summary.nodeCount,
-                        avgPageRank: summary.avgPageRank,
-                    });
-                }
-            }
-            const reranked = await this.memoryGraph.pprRerank(searchResults, this.semantic);
-            // Annotate each entry with its community ID and summary from GraphRAG
-            entries = reranked.map((r) => {
-                const commSummary = nodeToSummary.get(r.entry.id);
-                const community = r.community ?? commSummary?.communityId;
-                if (!community && !commSummary)
-                    return r.entry;
-                return {
-                    ...r.entry,
-                    metadata: {
-                        ...(r.entry.metadata ?? {}),
-                        community,
-                        ...(commSummary ? {
-                            communityNodeCount: commSummary.nodeCount,
-                            communityAvgPageRank: commSummary.avgPageRank,
-                        } : {}),
-                    },
-                };
-            });
-        }
-        else {
-            entries = searchResults.map((r) => r.entry);
-        }
-        // Injection filter: remove entries whose content matches known injection signatures
-        if (this.config.filterInjection) {
-            const safe = [];
-            for (const entry of entries) {
-                const content = entry.content ?? '';
-                if (INJECTION_PATTERNS.some(rx => rx.test(content))) {
-                    this.emit('injection:blocked', { id: entry.id, namespace: entry.namespace });
-                }
-                else {
-                    safe.push(entry);
-                }
-            }
-            entries = safe;
-        }
-        // Apply tag/namespace/type filters
-        if (query.filters) {
-            const f = query.filters;
-            if (f.tags && Array.isArray(f.tags)) {
-                const requiredTags = f.tags;
-                entries = entries.filter((e) => requiredTags.every((t) => e.tags.includes(t)));
-            }
-            if (f.namespace && typeof f.namespace === 'string') {
-                entries = entries.filter((e) => e.namespace === f.namespace);
-            }
-            if (f.type && typeof f.type === 'string' && f.type !== 'semantic') {
-                entries = entries.filter((e) => e.type === f.type);
-            }
-        }
-        return entries.slice(0, query.k || 10);
-    }
-    /**
-     * Hybrid queries (combine both)
-     * Intelligently merges results from both backends
-     */
-    async queryHybrid(query) {
-        this.stats.hybridQueries++;
-        const strategy = query.combineStrategy || 'semantic-first';
-        const weights = query.weights || { semantic: 0.7, structured: 0.3 };
-        // Execute both queries in parallel
-        const [semanticResults, structuredResults] = await Promise.all([
-            this.querySemantic(query.semantic),
-            query.structured ? this.queryStructured(query.structured) : Promise.resolve([]),
-        ]);
-        // Combine results based on strategy
-        switch (strategy) {
-            case 'union':
-                return this.combineUnion(semanticResults, structuredResults);
-            case 'intersection':
-                return this.combineIntersection(semanticResults, structuredResults);
-            case 'semantic-first':
-                return this.combineSemanticFirst(semanticResults, structuredResults);
-            case 'structured-first':
-                return this.combineStructuredFirst(semanticResults, structuredResults);
-            default:
-                return this.combineUnion(semanticResults, structuredResults);
-        }
-    }
-    /**
-     * Semantic vector search (routes to LanceDB)
-     */
-    async search(embedding, options) {
-        this.stats.semanticQueries++;
-        return this.semantic.search(embedding, options);
-    }
-    /**
-     * Bulk insert to both backends
-     */
-    async bulkInsert(entries) {
-        if (this.config.dualWrite) {
-            await Promise.all([this.sqlite.bulkInsert(entries), this.semantic.bulkInsert(entries)]);
-        }
-        else {
-            await this.semantic.bulkInsert(entries);
-        }
-    }
-    /**
-     * Bulk delete from both backends
-     */
-    async bulkDelete(ids) {
-        if (this.config.dualWrite) {
-            const [sqliteCount, semanticCount] = await Promise.all([
-                this.sqlite.bulkDelete(ids),
-                this.semantic.bulkDelete(ids),
-            ]);
-            return Math.max(sqliteCount, semanticCount);
-        }
-        else {
-            return this.semantic.bulkDelete(ids);
-        }
-    }
-    /**
-     * Count entries (use SQLite for efficiency)
-     */
-    async count(namespace) {
-        return this.sqlite.count(namespace);
-    }
-    /**
-     * List namespaces (use SQLite)
-     */
-    async listNamespaces() {
-        return this.sqlite.listNamespaces();
-    }
-    /**
-     * Clear namespace in both backends
-     */
-    async clearNamespace(namespace) {
-        if (this.config.dualWrite) {
-            const [sqliteCount, semanticCount] = await Promise.all([
-                this.sqlite.clearNamespace(namespace),
-                this.semantic.clearNamespace(namespace),
-            ]);
-            return Math.max(sqliteCount, semanticCount);
-        }
-        else {
-            return this.semantic.clearNamespace(namespace);
-        }
-    }
-    /**
-     * Get combined statistics from both backends
-     */
-    async getStats() {
-        const solo = this.semantic === this.sqlite;
-        const [sqliteStats, semanticStats] = await Promise.all([
-            solo ? Promise.resolve(null) : this.sqlite.getStats(),
-            this.semantic.getStats(),
-        ]);
-        return {
-            totalEntries: solo ? semanticStats.totalEntries : Math.max(sqliteStats.totalEntries, semanticStats.totalEntries),
-            entriesByNamespace: semanticStats.entriesByNamespace,
-            entriesByType: semanticStats.entriesByType,
-            memoryUsage: solo ? semanticStats.memoryUsage : sqliteStats.memoryUsage + semanticStats.memoryUsage,
-            hnswStats: semanticStats.hnswStats ?? {
-                vectorCount: 0, // 0 = no active HNSW index; do not fabricate from totalEntries
-                memoryUsage: 0,
-                avgSearchTime: 0,
-                buildTime: 0,
-                compressionRatio: 1.0,
-            },
-            cacheStats: semanticStats.cacheStats ?? {
-                hitRate: 0,
-                size: 0,
-                maxSize: 1000,
-            },
-            avgQueryTime: this.stats.hybridQueries + this.stats.sqliteQueries + this.stats.semanticQueries > 0
-                ? this.stats.totalQueryTime /
-                    (this.stats.hybridQueries + this.stats.sqliteQueries + this.stats.semanticQueries)
-                : 0,
-            avgSearchTime: semanticStats.avgSearchTime,
-        };
-    }
-    /**
-     * Health check for both backends
-     */
-    async healthCheck() {
-        const solo = this.semantic === this.sqlite;
-        const [sqliteHealth, semanticHealth] = await Promise.all([
-            solo ? Promise.resolve({ status: 'healthy', issues: [], recommendations: [], components: {}, timestamp: Date.now() }) : this.sqlite.healthCheck(),
-            this.semantic.healthCheck(),
-        ]);
-        const allIssues = [...sqliteHealth.issues, ...semanticHealth.issues];
-        const allRecommendations = [
-            ...sqliteHealth.recommendations,
-            ...semanticHealth.recommendations,
-        ];
-        // Determine overall status
-        let status = 'healthy';
-        if (sqliteHealth.status === 'unhealthy' ||
-            semanticHealth.status === 'unhealthy') {
-            status = 'unhealthy';
-        }
-        else if (sqliteHealth.status === 'degraded' ||
-            semanticHealth.status === 'degraded') {
-            status = 'degraded';
-        }
-        return {
-            status,
-            components: {
-                storage: sqliteHealth.components.storage,
-                index: semanticHealth.components.index,
-                cache: semanticHealth.components.cache,
-            },
-            timestamp: Date.now(),
-            issues: allIssues,
-            recommendations: allRecommendations,
-        };
-    }
-    // ===== Private Methods =====
-    /**
-     * Auto-route queries based on properties
-     */
-    async autoRoute(query) {
-        // If has embedding or content, use semantic search (LanceDB)
-        const hasEmbeddingGenerator = typeof this.config.embeddingGenerator === 'function';
-        if (query.embedding || (query.content && hasEmbeddingGenerator)) {
-            this.stats.semanticQueries++;
-            return this.semantic.query(query);
-        }
-        // If has exact key or prefix, use structured search (SQLite)
-        if (query.key || query.keyPrefix) {
-            this.stats.sqliteQueries++;
-            return this.sqlite.query(query);
-        }
-        // For other filters, use routing strategy
-        switch (this.config.routingStrategy) {
-            case 'sqlite-first':
-                this.stats.sqliteQueries++;
-                return this.sqlite.query(query);
-            case 'semantic-first':
-                this.stats.semanticQueries++;
-                return this.semantic.query(query);
-            case 'auto':
-            default:
-                // Default to semantic backend (LanceDB)
-                this.stats.semanticQueries++;
-                return this.semantic.query(query);
-        }
-    }
-    /**
-     * Internal hybrid query implementation
-     */
-    async queryHybridInternal(query) {
-        // If semantic component exists, use hybrid
-        if (query.embedding || query.content) {
-            const semanticQuery = {
-                content: query.content,
-                embedding: query.embedding,
-                k: query.limit || 10,
-                threshold: query.threshold,
-                filters: query,
-            };
-            const structuredQuery = {
-                namespace: query.namespace,
-                key: query.key,
-                keyPrefix: query.keyPrefix,
-                ownerId: query.ownerId,
-                type: query.memoryType,
-                createdAfter: query.createdAfter,
-                createdBefore: query.createdBefore,
-                updatedAfter: query.updatedAfter,
-                updatedBefore: query.updatedBefore,
-                limit: query.limit,
-                offset: query.offset,
-            };
-            return this.queryHybrid({
-                semantic: semanticQuery,
-                structured: structuredQuery,
-                combineStrategy: 'semantic-first',
-            });
-        }
-        // Otherwise, route to structured
-        return this.autoRoute(query);
-    }
-    /**
-     * Combine results using union (all unique results)
-     */
-    combineUnion(semanticResults, structuredResults) {
-        const seen = new Set();
-        const combined = [];
-        for (const entry of semanticResults) {
-            if (!seen.has(entry.id)) {
-                seen.add(entry.id);
-                combined.push(entry);
-            }
-        }
-        for (const entry of structuredResults) {
-            if (!seen.has(entry.id)) {
-                seen.add(entry.id);
-                combined.push(entry);
-            }
-        }
-        return combined;
-    }
-    /**
-     * Combine results using intersection (only common results)
-     */
-    combineIntersection(semanticResults, structuredResults) {
-        const semanticIds = new Set(semanticResults.map((e) => e.id));
-        return structuredResults.filter((e) => semanticIds.has(e.id));
-    }
-    /**
-     * Semantic-first: Prefer semantic results, add structured if not present
-     */
-    combineSemanticFirst(semanticResults, structuredResults) {
-        const semanticIds = new Set();
-        for (const e of semanticResults)
-            semanticIds.add(e.id);
-        const additional = structuredResults.filter((e) => !semanticIds.has(e.id));
-        return [...semanticResults, ...additional];
-    }
-    /**
-     * Structured-first: Prefer structured results, add semantic if not present
-     */
-    combineStructuredFirst(semanticResults, structuredResults) {
-        const structuredIds = new Set();
-        for (const e of structuredResults)
-            structuredIds.add(e.id);
-        const additional = semanticResults.filter((e) => !structuredIds.has(e.id));
-        return [...structuredResults, ...additional];
-    }
-    // ===== Proxy Methods — stubs for legacy controller API =====
-    /**
-     * Record feedback for a memory entry.
-     * Delegates to semantic backend's recordFeedback when available.
-     * Gracefully degrades to no-op when unavailable.
-     */
-    async recordFeedback(_entryId, _feedback) {
-        return false; // monolean: stub — LanceDB has no feedback API
-    }
-    async verifyWitnessChain(_entryId) {
-        return { valid: false, chainLength: 0, errors: ['not supported by LanceDB backend'] };
-    }
-    async getWitnessChain(_entryId) {
-        return [];
-    }
-    // ===== Backend Access =====
-    /**
-     * Get underlying backends for advanced operations
-     */
-    getSQLiteBackend() {
-        return this.sqlite;
-    }
-    getSemanticBackend() {
-        return this.semantic;
-    }
-}
-export default HybridBackend;
-//# sourceMappingURL=hybrid-backend.js.map