cozo-memory 1.0.0

package/dist/embedding-service.js

@@ -0,0 +1,249 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmbeddingService = void 0;
+const transformers_1 = require("@xenova/transformers");
+const ort = require('onnxruntime-node');
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// Robust path to project root
+const PROJECT_ROOT = path.resolve(__dirname, '..');
+const CACHE_DIR = path.resolve(PROJECT_ROOT, '.cache');
+transformers_1.env.cacheDir = CACHE_DIR;
+transformers_1.env.allowLocalModels = true;
+// Simple LRU Cache Implementation
+class LRUCache {
+    cache = new Map();
+    maxSize;
+    ttl;
+    constructor(maxSize = 1000, ttlMs = 3600000) {
+        this.maxSize = maxSize;
+        this.ttl = ttlMs;
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return undefined;
+        // Check TTL
+        if (Date.now() - entry.timestamp > this.ttl) {
+            this.cache.delete(key);
+            return undefined;
+        }
+        // Move to end (most recently used)
+        this.cache.delete(key);
+        this.cache.set(key, entry);
+        return entry.value;
+    }
+    set(key, value) {
+        // If key already exists, remove old position
+        if (this.cache.has(key)) {
+            this.cache.delete(key);
+        }
+        // If cache is full, remove oldest entry
+        else if (this.cache.size >= this.maxSize) {
+            const firstKey = this.cache.keys().next().value;
+            if (firstKey) {
+                this.cache.delete(firstKey);
+            }
+        }
+        this.cache.set(key, { value, timestamp: Date.now() });
+    }
+    clear() {
+        this.cache.clear();
+    }
+    size() {
+        return this.cache.size;
+    }
+}
+class EmbeddingService {
+    cache;
+    session = null;
+    tokenizer = null;
+    modelId = "Xenova/bge-m3";
+    dimensions = 1024;
+    queue = Promise.resolve();
+    constructor() {
+        this.cache = new LRUCache(1000, 3600000); // 1000 entries, 1h TTL
+    }
+    // Serializes embedding execution to avoid event loop blocking
+    async runSerialized(task) {
+        // Chain the task to the queue
+        const res = this.queue.then(() => task());
+        // Update the queue to wait for this task (but catch errors so queue doesn't stall)
+        this.queue = res.catch(() => { });
+        return res;
+    }
+    async init() {
+        if (this.session && this.tokenizer)
+            return;
+        try {
+            // 1. Load Tokenizer
+            if (!this.tokenizer) {
+                this.tokenizer = await transformers_1.AutoTokenizer.from_pretrained(this.modelId);
+            }
+            // 2. Determine model path
+            const baseDir = path.join(transformers_1.env.cacheDir, 'Xenova', 'bge-m3', 'onnx');
+            // Priority: FP32 (model.onnx) > Quantized (model_quantized.onnx)
+            let modelPath = path.join(baseDir, 'model.onnx');
+            if (!fs.existsSync(modelPath)) {
+                modelPath = path.join(baseDir, 'model_quantized.onnx');
+            }
+            if (!fs.existsSync(modelPath)) {
+                throw new Error(`Model file not found at: ${modelPath}`);
+            }
+            // 3. Create Session
+            if (!this.session) {
+                const options = {
+                    executionProviders: ['cpu'], // Use CPU backend to avoid native conflicts
+                    graphOptimizationLevel: 'all'
+                };
+                this.session = await ort.InferenceSession.create(modelPath, options);
+            }
+        }
+        catch (err) {
+            console.error("[EmbeddingService] Critical initialization error:", err);
+            throw err;
+        }
+    }
+    async embed(text) {
+        return this.runSerialized(async () => {
+            const textStr = String(text || "");
+            // 1. Cache lookup
+            const cached = this.cache.get(textStr);
+            if (cached) {
+                return cached;
+            }
+            try {
+                await this.init();
+                if (!this.session || !this.tokenizer)
+                    throw new Error("Session/Tokenizer not initialized");
+                // 2. Tokenization
+                const model_inputs = await this.tokenizer(textStr, { padding: true, truncation: true });
+                // 3. Tensor Creation
+                const feeds = {};
+                let attentionMaskData = null;
+                for (const [key, value] of Object.entries(model_inputs)) {
+                    if (key === 'input_ids' || key === 'attention_mask' || key === 'token_type_ids') {
+                        // @ts-ignore
+                        const data = BigInt64Array.from(value.data || value.cpuData);
+                        // @ts-ignore
+                        const dims = value.dims;
+                        // Store attention mask for pooling
+                        if (key === 'attention_mask') {
+                            attentionMaskData = data;
+                        }
+                        feeds[key] = new ort.Tensor('int64', data, dims);
+                    }
+                }
+                // 4. Inference
+                const results = await this.session.run(feeds);
+                // 5. Pooling & Normalization
+                // Output name usually 'last_hidden_state' or 'logits'
+                // For BGE-M3, the first output is usually the hidden states [batch, seq_len, hidden_size]
+                const outputName = this.session.outputNames[0];
+                const outputTensor = results[outputName];
+                // Ensure we have data
+                if (!outputTensor || !attentionMaskData) {
+                    throw new Error("No output data or attention mask available");
+                }
+                const embedding = this.meanPooling(outputTensor.data, attentionMaskData, outputTensor.dims);
+                // Normalize
+                const normalized = this.normalize(embedding);
+                this.cache.set(textStr, normalized);
+                return normalized;
+            }
+            catch (error) {
+                console.error(`[EmbeddingService] Error embedding "${textStr.substring(0, 20)}...":`, error?.message || error);
+                return new Array(this.dimensions).fill(0);
+            }
+        });
+    }
+    // Batch-Embeddings
+    async embedBatch(texts) {
+        // For now, process sequentially via serialized queue to avoid overloading
+        // In future, true batching can be implemented by passing array to tokenizer
+        const results = [];
+        for (const text of texts) {
+            results.push(await this.embed(text));
+        }
+        return results;
+    }
+    meanPooling(data, attentionMask, dims) {
+        // dims: [batch_size, seq_len, hidden_size]
+        // We assume batch_size = 1 for single embedding call
+        const [batchSize, seqLen, hiddenSize] = dims;
+        // Create accumulator
+        const embedding = new Float32Array(hiddenSize).fill(0);
+        let validTokens = 0;
+        for (let i = 0; i < seqLen; i++) {
+            // Check mask (1 = valid token, 0 = padding)
+            if (attentionMask[i] === 1n) {
+                validTokens++;
+                for (let j = 0; j < hiddenSize; j++) {
+                    // data is flat array: [batch * seq * hidden]
+                    // index = i * hiddenSize + j
+                    embedding[j] += data[i * hiddenSize + j];
+                }
+            }
+        }
+        // Divide by valid count
+        if (validTokens > 0) {
+            for (let j = 0; j < hiddenSize; j++) {
+                embedding[j] /= validTokens;
+            }
+        }
+        return Array.from(embedding);
+    }
+    normalize(vector) {
+        const norm = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
+        if (norm === 0)
+            return vector;
+        return vector.map(v => v / norm);
+    }
+    // Cache Statistics
+    getCacheStats() {
+        return {
+            size: this.cache.size(),
+            maxSize: 1000,
+            model: this.modelId,
+            dimensions: this.dimensions
+        };
+    }
+    // Clear Cache
+    clearCache() {
+        this.cache.clear();
+    }
+}
+exports.EmbeddingService = EmbeddingService;

package/dist/full-system-test.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const perf_hooks_1 = require("perf_hooks");
+async function runFullSystemTest() {
+    // DB path is handled internally by MemoryServer
+    console.log("🚀 Starting Full System Test (v0.8.5)...");
+    const memory = new index_1.MemoryServer();
+    console.log("\n--- 1. Setup & Schema ---");
+    await memory.initPromise;
+    console.log("✅ Schema initialized.");
+    console.log("\n--- 2. Data Ingest & Memory Creation ---");
+    const e1 = await memory.createEntity({
+        name: "user_123",
+        type: "User",
+        metadata: { description: "A test user" }
+    });
+    if (e1.error) {
+        console.error("Failed to create entity:", e1.error);
+        return;
+    }
+    const o1 = await memory.addObservation({
+        entity_id: e1.id,
+        text: "User prefers dark mode and likes coding in TypeScript.",
+    });
+    console.log("✅ Observation 1 added.");
+    console.log("\n--- 3. Cache System (L1, L2, Semantic) ---");
+    // Query 1: Cold start
+    const t1 = perf_hooks_1.performance.now();
+    await memory.advancedSearch({ query: "dark mode preference" });
+    const d1 = perf_hooks_1.performance.now() - t1;
+    console.log("Query 1 (Cold Start)...");
+    console.log(`⏱️ Duration: ${d1.toFixed(2)}ms`);
+    // Query 1: Repeat (L1 Cache)
+    const t2 = perf_hooks_1.performance.now();
+    await memory.advancedSearch({ query: "dark mode preference" });
+    const d2 = perf_hooks_1.performance.now() - t2;
+    console.log("\nQuery 1 (L1 Memory Cache)...");
+    console.log(`⏱️ Duration: ${d2.toFixed(2)}ms`);
+    if (d2 < 5)
+        console.log("✅ SUCCESS: L1 Cache Hit (< 5ms)");
+    // Query 2: Semantic Cache (similar query)
+    // ... (rest of the test if any)
+}
+runFullSystemTest().catch(console.error);

package/dist/hybrid-search.js

@@ -0,0 +1,337 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridSearch = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const SEMANTIC_CACHE_THRESHOLD = 0.95;
+class HybridSearch {
+    db;
+    embeddingService;
+    searchCache = new Map();
+    CACHE_TTL = 300000; // 5 minutes cache
+    constructor(db, embeddingService) {
+        this.db = db;
+        this.embeddingService = embeddingService;
+    }
+    getCacheKey(options) {
+        const str = JSON.stringify({
+            q: options.query,
+            l: options.limit,
+            t: options.entityTypes,
+            io: options.includeObservations,
+            ie: options.includeEntities,
+            tr: options.timeRangeHours,
+            f: options.filters,
+            g: options.graphConstraints,
+            v: options.vectorParams
+        });
+        return crypto_1.default.createHash('md5').update(str).digest('hex');
+    }
+    async tryCacheLookup(options, queryEmbedding) {
+        const cacheKey = this.getCacheKey(options);
+        const cached = this.searchCache.get(cacheKey);
+        if (cached && (Date.now() - cached.timestamp < this.CACHE_TTL)) {
+            console.error(`[HybridSearch] In-Memory cache hit for key: ${cacheKey}`);
+            return cached.results;
+        }
+        try {
+            const exactRes = await this.db.run('?[results] := *search_cache{query_hash: $hash, results, created_at}, created_at > $min_ts', { hash: cacheKey, min_ts: Math.floor((Date.now() - this.CACHE_TTL) / 1000) });
+            if (exactRes.rows.length > 0) {
+                console.error(`[HybridSearch] DB cache hit for key: ${cacheKey}`);
+                const results = exactRes.rows[0][0];
+                this.searchCache.set(cacheKey, { results, timestamp: Date.now() });
+                return results;
+            }
+        }
+        catch (e) {
+            console.error(`[HybridSearch] Cache lookup error or table missing: ${e.message}`);
+        }
+        return null;
+    }
+    async updateCache(options, queryEmbedding, results) {
+        const cacheKey = this.getCacheKey(options);
+        this.searchCache.set(cacheKey, { results, timestamp: Date.now() });
+        try {
+            await this.db.run('?[query_hash, results, options, created_at, embedding] <- [[$hash, $res, $opt, $now, vec($emb)]] :put search_cache{query_hash}', { hash: cacheKey, res: results, opt: options, now: Math.floor(Date.now() / 1000), emb: queryEmbedding });
+        }
+        catch (e) { }
+    }
+    applyTimeDecay(results) {
+        return results.map(r => {
+            let score = Number(r.score);
+            if (isNaN(score))
+                score = 0;
+            if (r.created_at) {
+                const createdAt = Array.isArray(r.created_at) ? r.created_at[0] : r.created_at;
+                const ageHours = (Date.now() - Number(createdAt) / 1000) / (1000 * 60 * 60);
+                const decay = Math.pow(0.5, ageHours / (24 * 90)); // 90 days half-life
+                let newScore = score * decay;
+                if (isNaN(newScore))
+                    newScore = 0;
+                return { ...r, score: newScore };
+            }
+            return { ...r, score };
+        });
+    }
+    async advancedSearch(options) {
+        console.error("[HybridSearch] Starting advancedSearch with options:", JSON.stringify(options, null, 2));
+        const { query, limit = 10, filters, graphConstraints, vectorParams } = options;
+        let queryEmbedding;
+        try {
+            queryEmbedding = await this.embeddingService.embed(query);
+        }
+        catch (e) {
+            console.error("[HybridSearch] Embedding failed", e);
+            throw e;
+        }
+        const cachedResults = await this.tryCacheLookup(options, queryEmbedding);
+        if (cachedResults !== null) {
+            console.error("[HybridSearch] Cache hit for advancedSearch");
+            return cachedResults;
+        }
+        console.error("[HybridSearch] Cache miss, executing Datalog query...");
+        let topk = limit * 2;
+        const hasFilters = (filters?.metadata && Object.keys(filters.metadata).length > 0) ||
+            (filters?.entityTypes && filters.entityTypes.length > 0);
+        if (hasFilters) {
+            // Significantly increase topk for post-filtering
+            topk = Math.max(limit * 20, 200);
+        }
+        const params = {
+            query_vector: queryEmbedding,
+            limit: limit,
+            topk: topk,
+            ef_search: vectorParams?.efSearch || 100,
+        };
+        let hnswFilters = [];
+        const metaRules = [];
+        const metaJoins = [];
+        if (filters?.metadata) {
+            Object.entries(filters.metadata).forEach(([key, value], index) => {
+                const paramName = `meta_val_${index}`;
+                params[paramName] = value;
+                // Use metadata->'key' syntax which is correct for CozoDB JSON access
+                metaJoins.push(`metadata->'${key}' == $${paramName}`);
+            });
+        }
+        if (filters?.entityTypes && filters.entityTypes.length > 0) {
+            params.allowed_types = filters.entityTypes;
+            // Post-filtering for types
+            metaJoins.push(`is_in(type, $allowed_types)`);
+        }
+        // Use filtered indexes if possible (v1.7)
+        let indexToUse = "entity:semantic";
+        if (filters?.entityTypes && filters.entityTypes.length === 1) {
+            const requestedType = filters.entityTypes[0].toLowerCase();
+            const supportedFilteredIndexes = ['person', 'project', 'task', 'note'];
+            if (supportedFilteredIndexes.includes(requestedType)) {
+                indexToUse = `entity:semantic_${requestedType}`;
+            }
+        }
+        // Multi-Vector Support: Use name_embedding if query is short (v1.7)
+        let indexToSearch = indexToUse;
+        const isShortQuery = query.split(' ').length <= 3;
+        if (isShortQuery && !filters?.entityTypes) {
+            // For short queries without type filter, the name_semantic index is often more precise
+            indexToSearch = "entity:name_semantic";
+        }
+        let semanticCall = `~${indexToSearch}{id | query: vec($query_vector), k: $topk, ef: $ef_search, bind_distance: dist`;
+        if (hnswFilters.length > 0) {
+            semanticCall += `, filter: ${hnswFilters.join(" && ")}`;
+        }
+        semanticCall += `}`;
+        let bodyConstraints = [semanticCall, `*entity{id, name, type, metadata, created_at}`];
+        if (metaJoins.length > 0) {
+            bodyConstraints.push(...metaJoins);
+        }
+        if (options.timeRangeHours) {
+            const minTs = Date.now() - (options.timeRangeHours * 3600 * 1000);
+            params.min_ts = minTs;
+        }
+        if (graphConstraints?.requiredRelations && graphConstraints.requiredRelations.length > 0) {
+            graphConstraints.requiredRelations.forEach((relType, index) => {
+                const relParam = `rel_type_${index}`;
+                params[relParam] = relType;
+                bodyConstraints.push(`rel_match[id, $${relParam}]`);
+            });
+        }
+        if (graphConstraints?.targetEntityIds && graphConstraints.targetEntityIds.length > 0) {
+            params.target_ids = graphConstraints.targetEntityIds;
+            bodyConstraints.push(`target_match[id, t_id]`, `is_in(t_id, $target_ids)`);
+        }
+        if (filters?.minScore) {
+            params.min_score = filters.minScore;
+            bodyConstraints.push(`score >= $min_score`);
+        }
+        const helperRules = [
+            `rank_val[id, r] := *entity_rank{entity_id: id, pagerank: r}`,
+            `rank_val[id, r] := *entity{id, @ "NOW"}, not *entity_rank{entity_id: id}, r = 0.0`
+        ];
+        if (graphConstraints?.requiredRelations && graphConstraints.requiredRelations.length > 0) {
+            helperRules.push(`rel_match[id, rel_type] := *relationship{from_id: id, relation_type: rel_type}`, `rel_match[id, rel_type] := *relationship{to_id: id, relation_type: rel_type}`);
+        }
+        if (graphConstraints?.targetEntityIds && graphConstraints.targetEntityIds.length > 0) {
+            helperRules.push(`target_match[id, target_id] := *relationship{from_id: id, to_id: target_id}`, `target_match[id, target_id] := *relationship{to_id: id, from_id: target_id}`);
+        }
+        const datalogQuery = [
+            ...helperRules,
+            `?[id, name, type, metadata, created_at, score, dist] := ${bodyConstraints.join(', ')}, rank_val[id, pr], score = (1.0 - dist)`,
+            `:sort -score`,
+            `:limit $limit`
+        ].join('\n').trim();
+        console.error('--- DEBUG: Cozo Datalog Query ---');
+        console.error(datalogQuery);
+        console.error('--- DEBUG: Params ---');
+        console.dir(params, { depth: null });
+        try {
+            const results = await this.db.run(datalogQuery, params);
+            let searchResults = results.rows.map((r) => ({
+                id: r[0],
+                entity_id: r[0],
+                name: r[1],
+                type: r[2],
+                metadata: r[3],
+                explanation: `DEBUG: raw_score=${r[5]}, dist=${r[6]}`,
+                created_at: Array.isArray(r[4]) ? r[4][0] : r[4], // CozoDB returns [start, end] for Validity
+                score: Number(r[5]) || 0,
+                source: "advanced_hybrid",
+            }));
+            // Post-Filtering for Time Range
+            if (options.timeRangeHours) {
+                const minTs = Date.now() - (options.timeRangeHours * 3600 * 1000);
+                searchResults = searchResults.filter(r => (r.created_at || 0) > minTs);
+            }
+            // Post-Filtering for Metadata (since CozoDB get() in Datalog often fails)
+            if (filters?.metadata) {
+                searchResults = searchResults.filter(r => {
+                    if (!r.metadata || typeof r.metadata !== 'object')
+                        return false;
+                    return Object.entries(filters.metadata).every(([key, val]) => r.metadata[key] === val);
+                });
+            }
+            const finalResults = this.applyTimeDecay(searchResults);
+            await this.updateCache(options, queryEmbedding, finalResults);
+            return finalResults;
+        }
+        catch (e) {
+            console.error("[HybridSearch] Error in advancedSearch:", e.message);
+            return this.search(options);
+        }
+    }
+    async search(options) {
+        const { query, limit = 10 } = options;
+        const queryEmbedding = await this.embeddingService.embed(query);
+        const cachedResults = await this.tryCacheLookup(options, queryEmbedding);
+        if (cachedResults) {
+            // Add debug info to cached results too
+            return cachedResults.map(r => ({
+                ...r,
+                explanation: (typeof r.explanation === 'string' ? r.explanation : JSON.stringify(r.explanation)) + ` | CACHED`
+            }));
+        }
+        const { limit: queryLimit = 10, filters, graphConstraints, vectorParams } = options;
+        // @ts-ignore
+        const { topk = 5, efSearch = 50 } = vectorParams || {};
+        // Fallback Mock
+        return [];
+    }
+    async graphRag(options) {
+        console.error("[HybridSearch] Starting graphRag with options:", JSON.stringify(options, null, 2));
+        const { query, limit = 5, filters, graphConstraints } = options;
+        const maxDepth = graphConstraints?.maxDepth || 2;
+        const queryEmbedding = await this.embeddingService.embed(query);
+        const topk = limit * 2;
+        const params = {
+            query_vector: queryEmbedding,
+            topk: topk,
+            ef_search: 100,
+            max_depth: maxDepth,
+            limit: limit
+        };
+        let hnswFilters = [];
+        const metaRules = [];
+        const metaJoins = [];
+        if (filters?.entityTypes && filters.entityTypes.length > 0) {
+            params.allowed_types = filters.entityTypes;
+            hnswFilters.push(`is_in(type, $allowed_types)`);
+        }
+        if (filters?.metadata) {
+            Object.entries(filters.metadata).forEach(([key, value], index) => {
+                const paramName = `meta_val_${index}`;
+                params[paramName] = value;
+            });
+        }
+        let seedSemanticCall = `~entity:semantic{id, type, metadata | query: vec($query_vector), k: $topk, ef: $ef_search, bind_distance: dist`;
+        if (hnswFilters.length > 0) {
+            seedSemanticCall += `, filter: ${hnswFilters.join(" && ")}`;
+        }
+        seedSemanticCall += `}`;
+        let seedConstraints = [seedSemanticCall];
+        if (options.timeRangeHours) {
+            const minTs = Date.now() - (options.timeRangeHours * 3600 * 1000);
+            params.min_ts = minTs;
+        }
+        // Datalog Query for Graph-RAG:
+        // 1. Find seed entities via vector search (with inline filtering)
+        // 2. Explore the graph starting from seeds up to maxDepth hops
+        // 3. Collect all reached entities and observations
+        // 4. Calculate a combined score based on vector distance, graph distance, and PageRank
+        const datalogQuery = `
+      rank_val[id, r] := *entity_rank{entity_id: id, pagerank: r}
+      rank_val[id, r] := *entity{id, @ "NOW"}, not *entity_rank{entity_id: id}, r = 0.0
+
+      seeds[id, score] := ${seedConstraints.join(", ")}, score = 1.0 - dist
+      
+      path[start_id, current_id, d] := seeds[start_id, _], current_id = start_id, d = 0
+      path[start_id, next_id, d_new] := path[start_id, current_id, d], *relationship{from_id: current_id, to_id: next_id}, d < $max_depth, d_new = d + 1
+      path[start_id, next_id, d_new] := path[start_id, current_id, d], *relationship{to_id: current_id, from_id: next_id}, d < $max_depth, d_new = d + 1
+
+      result_entities[id, final_score, depth] := path[seed_id, id, depth], seeds[seed_id, seed_score], rank_val[id, pr], final_score = seed_score * (1.0 - 0.2 * depth)
+      
+      ?[id, name, type, metadata, created_at, score, source, text] := result_entities[id, score, depth], *entity{id, name, type, metadata, created_at}, source = 'graph_rag_entity', text = ''
+      
+      :sort -score
+      :limit $limit
+    `.trim();
+        console.error("[HybridSearch] Graph-RAG Datalog Query:\n", datalogQuery);
+        try {
+            const results = await this.db.run(datalogQuery, params);
+            let searchResults = results.rows.map((r) => ({
+                id: r[0],
+                name: r[1],
+                type: r[2],
+                metadata: r[3],
+                created_at: Array.isArray(r[4]) ? r[4][0] : r[4],
+                score: Number(r[5]) || 0,
+                source: r[6],
+                text: r[7] || undefined,
+                explanation: {
+                    source_score: r[5],
+                    details: `Found via graph expansion (Source: ${r[6]})`
+                }
+            }));
+            // Post-filtering for time range
+            if (options.timeRangeHours) {
+                const minTs = Date.now() - (options.timeRangeHours * 3600 * 1000);
+                searchResults = searchResults.filter(r => (r.created_at || 0) > minTs);
+            }
+            // Post-filtering for metadata
+            if (filters?.metadata) {
+                searchResults = searchResults.filter(r => {
+                    if (!r.metadata || typeof r.metadata !== 'object')
+                        return false;
+                    return Object.entries(filters.metadata).every(([key, val]) => r.metadata[key] === val);
+                });
+            }
+            return this.applyTimeDecay(searchResults);
+        }
+        catch (e) {
+            console.error("[HybridSearch] Error in graphRag:", e.message);
+            // Fallback to normal search on error
+            return this.search(options);
+        }
+    }
+}
+exports.HybridSearch = HybridSearch;