cozo-memory 1.1.8 → 1.2.1

package/dist/adaptive-retrieval.js

@@ -322,6 +322,11 @@ class AdaptiveGraphRetrieval {
      * Main adaptive retrieval method
      */
     async retrieve(query, limit = 10) {
+        // Validate limit to prevent errors
+        if (limit <= 0) {
+            console.error('[AdaptiveRetrieval] Invalid limit value:', limit, '- must be positive. Defaulting to 10.');
+            limit = 10;
+        }
         // 1. Classify query complexity
         const complexity = this.classifyQueryComplexity(query);
         console.error(`[AdaptiveRetrieval] Query complexity: ${complexity}`);
@@ -338,6 +343,11 @@ class AdaptiveGraphRetrieval {
     }
     // ==================== Strategy Implementations ====================
     async vectorSearch(embedding, limit) {
+        // Validate limit
+        if (limit <= 0) {
+            console.error('[AdaptiveRetrieval] Invalid limit in vectorSearch:', limit);
+            return [];
+        }
         const result = await this.db.run(`
       ?[id, name, type, score] :=
         ~entity:semantic{id | query: vec($embedding), k: $limit, ef: 100, bind_distance: dist},

package/dist/dynamic-fusion.js

@@ -74,10 +74,23 @@ class DynamicFusionSearch {
      */
     async search(query, config = {}) {
         const startTime = Date.now();
+        // Merge config with defaults first
+        const fullConfig = this.mergeConfig(config);
+        // Validate topK values to prevent errors
+        if (fullConfig.vector && fullConfig.vector.topK <= 0) {
+            console.error('[DynamicFusion] Invalid vector.topK:', fullConfig.vector.topK, '- must be positive. Defaulting to 20.');
+            fullConfig.vector.topK = 20;
+        }
+        if (fullConfig.sparse && fullConfig.sparse.topK <= 0) {
+            console.error('[DynamicFusion] Invalid sparse.topK:', fullConfig.sparse.topK, '- must be positive. Defaulting to 20.');
+            fullConfig.sparse.topK = 20;
+        }
+        if (fullConfig.fts && fullConfig.fts.topK <= 0) {
+            console.error('[DynamicFusion] Invalid fts.topK:', fullConfig.fts.topK, '- must be positive. Defaulting to 20.');
+            fullConfig.fts.topK = 20;
+        }
         // Get adaptive weights based on query classification
         const adaptiveWeights = await this.adaptiveQueryFusion.getAdaptiveWeights(query);
-        // Merge config with defaults first, then apply adaptive weights
-        const fullConfig = this.mergeConfig(config);
         // Override weights with adaptive values
         fullConfig.vector.weight = adaptiveWeights.vector;
         fullConfig.sparse.weight = adaptiveWeights.sparse;

package/dist/emotional-salience.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EmotionalSalienceService = void 0;
+/**
+ * Emotional Salience Keywords
+ *
+ * Organized by intensity and category based on psychological research
+ * and biological memory enhancement patterns.
+ */
+const SALIENCE_KEYWORDS = {
+    // High Intensity (0.8-1.0) - Critical, urgent, never forget
+    critical: {
+        weight: 1.0,
+        keywords: [
+            'critical', 'crucial', 'vital', 'essential', 'must', 'never forget',
+            'always remember', 'extremely important', 'life-changing', 'breakthrough',
+            'emergency', 'urgent', 'immediate', 'asap', 'priority one'
+        ]
+    },
+    // High Importance (0.6-0.8) - Important, significant
+    important: {
+        weight: 0.8,
+        keywords: [
+            'important', 'significant', 'key', 'major', 'primary', 'fundamental',
+            'noteworthy', 'remarkable', 'substantial', 'considerable', 'priority',
+            'high priority', 'top priority', 'remember this', 'don\'t forget'
+        ]
+    },
+    // Emotional Arousal (0.5-0.7) - Surprise, excitement, concern
+    emotional: {
+        weight: 0.7,
+        keywords: [
+            'surprising', 'unexpected', 'shocking', 'amazing', 'incredible',
+            'exciting', 'thrilling', 'alarming', 'concerning', 'worrying',
+            'breakthrough', 'discovery', 'revelation', 'game-changer'
+        ]
+    },
+    // Temporal Urgency (0.5-0.7) - Time-sensitive
+    temporal: {
+        weight: 0.6,
+        keywords: [
+            'deadline', 'due', 'expires', 'time-sensitive', 'limited time',
+            'soon', 'quickly', 'immediately', 'now', 'today', 'this week',
+            'before', 'until', 'by'
+        ]
+    },
+    // Negative Salience (0.4-0.6) - Problems, risks, warnings
+    negative: {
+        weight: 0.5,
+        keywords: [
+            'problem', 'issue', 'bug', 'error', 'failure', 'risk', 'danger',
+            'warning', 'alert', 'caution', 'concern', 'threat', 'vulnerability',
+            'critical bug', 'security issue', 'data loss'
+        ]
+    },
+    // Positive Salience (0.4-0.6) - Success, achievement
+    positive: {
+        weight: 0.5,
+        keywords: [
+            'success', 'achievement', 'milestone', 'completed', 'solved',
+            'accomplished', 'victory', 'win', 'breakthrough', 'innovation',
+            'excellent', 'outstanding', 'exceptional'
+        ]
+    },
+    // Moderate Importance (0.3-0.5) - Notable, relevant
+    moderate: {
+        weight: 0.4,
+        keywords: [
+            'notable', 'relevant', 'useful', 'helpful', 'valuable', 'worth noting',
+            'interesting', 'attention', 'note', 'reminder', 'tip', 'advice'
+        ]
+    }
+};
+class EmotionalSalienceService {
+    db;
+    config;
+    constructor(db, config = {}) {
+        this.db = db;
+        this.config = {
+            enableSalience: true,
+            salienceBoostFactor: 2.0,
+            decaySlowdownFactor: 0.5,
+            minSalienceThreshold: 0.3,
+            updateExistingObservations: false,
+            ...config
+        };
+    }
+    /**
+     * Calculate emotional salience score for a text
+     */
+    calculateSalienceScore(text) {
+        const lowerText = text.toLowerCase();
+        const detectedKeywords = [];
+        // Scan for keywords in each category
+        for (const [categoryName, categoryData] of Object.entries(SALIENCE_KEYWORDS)) {
+            for (const keyword of categoryData.keywords) {
+                // Use word boundaries for accurate matching
+                const regex = new RegExp(`\\b${keyword.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`, 'i');
+                if (regex.test(text)) {
+                    detectedKeywords.push({
+                        keyword,
+                        weight: categoryData.weight,
+                        category: categoryName
+                    });
+                }
+            }
+        }
+        // Calculate weighted score
+        let totalScore = 0;
+        let maxWeight = 0;
+        for (const detected of detectedKeywords) {
+            totalScore += detected.weight;
+            maxWeight = Math.max(maxWeight, detected.weight);
+        }
+        // Normalize: Use max weight if multiple keywords, with diminishing returns
+        const score = detectedKeywords.length === 0
+            ? 0
+            : Math.min(1.0, maxWeight + (totalScore - maxWeight) * 0.2);
+        // Categorize
+        let category;
+        if (score >= 0.7)
+            category = 'high';
+        else if (score >= 0.4)
+            category = 'medium';
+        else if (score >= 0.3)
+            category = 'low';
+        else
+            category = 'neutral';
+        // Generate reason
+        const uniqueKeywords = [...new Set(detectedKeywords.map(d => d.keyword))];
+        const reason = detectedKeywords.length === 0
+            ? 'No emotional salience keywords detected'
+            : `Detected ${detectedKeywords.length} salience keyword(s): ${uniqueKeywords.slice(0, 3).join(', ')}${uniqueKeywords.length > 3 ? '...' : ''}`;
+        return {
+            score,
+            keywords: uniqueKeywords,
+            category,
+            reason
+        };
+    }
+    /**
+     * Calculate salience boost for memory activation
+     */
+    calculateBoost(salienceScore) {
+        if (salienceScore < this.config.minSalienceThreshold) {
+            return { strengthMultiplier: 1.0, decayReduction: 0.0 };
+        }
+        // Strength multiplier: 1.0 to salienceBoostFactor (default: 2.0)
+        const strengthMultiplier = 1.0 + (salienceScore * (this.config.salienceBoostFactor - 1.0));
+        // Decay reduction: 0.0 to decaySlowdownFactor (default: 0.5)
+        // Higher salience = slower decay
+        const decayReduction = salienceScore * this.config.decaySlowdownFactor;
+        return { strengthMultiplier, decayReduction };
+    }
+    /**
+     * Score all observations for emotional salience
+     */
+    async scoreAllObservations() {
+        if (!this.config.enableSalience) {
+            return [];
+        }
+        try {
+            // Fetch all observations (without time travel if not supported)
+            const result = await this.db.run(`
+        ?[id, text, entity_id] := *observation{id, text, entity_id}
+      `);
+            const scores = [];
+            for (const row of result.rows) {
+                const [id, text, entityId] = row;
+                const { score, keywords, category, reason } = this.calculateSalienceScore(text);
+                const boost = this.calculateBoost(score);
+                scores.push({
+                    observationId: id,
+                    text: text,
+                    salienceScore: score,
+                    detectedKeywords: keywords,
+                    category,
+                    boost,
+                    reason
+                });
+            }
+            return scores.sort((a, b) => b.salienceScore - a.salienceScore);
+        }
+        catch (error) {
+            console.error('[EmotionalSalience] Error scoring observations:', error);
+            return [];
+        }
+    }
+    /**
+     * Apply salience metadata to observations
+     */
+    async applySalienceMetadata(dryRun = false) {
+        const scores = await this.scoreAllObservations();
+        const toUpdate = scores.filter(s => s.salienceScore >= this.config.minSalienceThreshold);
+        if (dryRun) {
+            return { updated: 0, scores: toUpdate, dryRun: true };
+        }
+        let updated = 0;
+        for (const score of toUpdate) {
+            try {
+                // Update observation metadata with salience information
+                await this.db.run(`
+          ?[id, entity_id, text, metadata] := 
+            *observation{id, entity_id, text, metadata},
+            id = $id,
+            new_metadata = {
+              "emotional_salience": $salience_score,
+              "salience_category": $category,
+              "salience_keywords": $keywords,
+              "salience_boost_strength": $strength_multiplier,
+              "salience_boost_decay": $decay_reduction
+            },
+            metadata = if(is_null(metadata), new_metadata, concat(metadata, new_metadata))
+          
+          :put observation {id, entity_id, text, metadata}
+        `, {
+                    id: score.observationId,
+                    salience_score: score.salienceScore,
+                    category: score.category,
+                    keywords: JSON.stringify(score.detectedKeywords),
+                    strength_multiplier: score.boost.strengthMultiplier,
+                    decay_reduction: score.boost.decayReduction
+                });
+                updated++;
+            }
+            catch (error) {
+                console.error(`[EmotionalSalience] Error updating observation ${score.observationId}:`, error);
+            }
+        }
+        return { updated, scores: toUpdate, dryRun: false };
+    }
+    /**
+     * Get salience statistics
+     */
+    async getSalienceStats() {
+        const scores = await this.scoreAllObservations();
+        const distribution = {
+            high: scores.filter(s => s.category === 'high').length,
+            medium: scores.filter(s => s.category === 'medium').length,
+            low: scores.filter(s => s.category === 'low').length,
+            neutral: scores.filter(s => s.category === 'neutral').length
+        };
+        const averageSalience = scores.length > 0
+            ? scores.reduce((sum, s) => sum + s.salienceScore, 0) / scores.length
+            : 0;
+        // Count keyword frequencies
+        const keywordCounts = new Map();
+        for (const score of scores) {
+            for (const keyword of score.detectedKeywords) {
+                keywordCounts.set(keyword, (keywordCounts.get(keyword) || 0) + 1);
+            }
+        }
+        const topKeywords = Array.from(keywordCounts.entries())
+            .map(([keyword, count]) => ({ keyword, count }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 10);
+        return {
+            totalObservations: scores.length,
+            withSalience: scores.filter(s => s.salienceScore >= this.config.minSalienceThreshold).length,
+            distribution,
+            averageSalience,
+            topKeywords
+        };
+    }
+    /**
+     * Get salience score for a specific observation
+     */
+    async getObservationSalience(observationId) {
+        try {
+            const result = await this.db.run(`
+        ?[id, text] := *observation{id, text}, id = $id
+      `, { id: observationId });
+            if (result.rows.length === 0) {
+                return null;
+            }
+            const [id, text] = result.rows[0];
+            const { score, keywords, category, reason } = this.calculateSalienceScore(text);
+            const boost = this.calculateBoost(score);
+            return {
+                observationId: id,
+                text: text,
+                salienceScore: score,
+                detectedKeywords: keywords,
+                category,
+                boost,
+                reason
+            };
+        }
+        catch (error) {
+            console.error('[EmotionalSalience] Error getting observation salience:', error);
+            return null;
+        }
+    }
+}
+exports.EmotionalSalienceService = EmotionalSalienceService;

package/dist/hybrid-search.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HybridSearch = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const reranker_service_1 = require("./reranker-service");
+const logger_1 = require("./logger");
+const performance_monitor_1 = require("./performance-monitor");
 const SEMANTIC_CACHE_THRESHOLD = 0.95;
 class HybridSearch {
     db;
@@ -138,22 +140,30 @@ class HybridSearch {
         }
     }
     async advancedSearch(options) {
-        console.error("[HybridSearch] Starting advancedSearch with options:", JSON.stringify(options, null, 2));
+        logger_1.logger.debug('HybridSearch', 'Starting advancedSearch', { query: options.query, limit: options.limit });
         const { query, limit = 10, filters, graphConstraints, vectorParams } = options;
+        // Validate limit to prevent infinite loops
+        if (limit <= 0) {
+            logger_1.logger.warn('HybridSearch', `Invalid limit value: ${limit} - must be positive. Defaulting to 10.`);
+            options.limit = 10;
+        }
+        const endTimer = performance_monitor_1.perfMonitor.startTimer('advancedSearch');
         let queryEmbedding;
         try {
             queryEmbedding = await this.embeddingService.embed(query);
         }
         catch (e) {
-            console.error("[HybridSearch] Embedding failed", e);
+            logger_1.logger.error('HybridSearch', 'Embedding failed', e);
+            endTimer();
             throw e;
         }
         const cachedResults = await this.tryCacheLookup(options, queryEmbedding);
         if (cachedResults !== null) {
-            console.error("[HybridSearch] Cache hit for advancedSearch");
+            logger_1.logger.debug('HybridSearch', 'Cache hit for advancedSearch');
+            endTimer();
             return cachedResults;
         }
-        console.error("[HybridSearch] Cache miss, executing Datalog query...");
+        logger_1.logger.trace('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);
@@ -204,7 +214,7 @@ class HybridSearch {
             semanticCall += `, filter: ${hnswFilters.join(" && ")}`;
         }
         semanticCall += `}`;
-        let bodyConstraints = [semanticCall, `*entity{id, name, type, metadata, created_at, @ "NOW"}`];
+        let bodyConstraints = [semanticCall, `*entity{id, name, type, metadata, created_at}`];
         if (metaJoins.length > 0) {
             bodyConstraints.push(...metaJoins);
         }
@@ -229,13 +239,13 @@ class HybridSearch {
         }
         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`
+            `rank_val[id, r] := *entity{id}, 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, @ "NOW"}`, `rel_match[id, rel_type] := *relationship{to_id: id, relation_type: rel_type, @ "NOW"}`);
+            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, @ "NOW"}`, `target_match[id, target_id] := *relationship{to_id: id, from_id: target_id, @ "NOW"}`);
+            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,
@@ -278,11 +288,16 @@ class HybridSearch {
                 return rerankedResults;
             }
             await this.updateCache(options, queryEmbedding, finalResults);
+            endTimer();
             return finalResults;
         }
         catch (e) {
-            console.error("[HybridSearch] Error in advancedSearch:", e.message);
-            return this.search(options);
+            logger_1.logger.error('HybridSearch', 'Error in advancedSearch', e.message);
+            performance_monitor_1.perfMonitor.recordMetric('advancedSearch', 0, true);
+            endTimer();
+            // Prevent infinite recursion by returning empty results instead of calling search()
+            logger_1.logger.warn('HybridSearch', 'Returning empty results to prevent infinite loop');
+            return [];
         }
     }
     async search(options) {
@@ -308,8 +323,14 @@ class HybridSearch {
         });
     }
     async graphRag(options) {
-        console.error("[HybridSearch] Starting graphRag with options:", JSON.stringify(options, null, 2));
+        logger_1.logger.debug('HybridSearch', 'Starting graphRag', { query: options.query, limit: options.limit });
         const { query, limit = 5, filters, graphConstraints } = options;
+        // Validate limit to prevent infinite loops
+        if (limit <= 0) {
+            logger_1.logger.warn('HybridSearch', `Invalid limit value: ${limit} - must be positive. Defaulting to 5.`);
+            options.limit = 5;
+        }
+        const endTimer = performance_monitor_1.perfMonitor.startTimer('graphRag');
         const maxDepth = graphConstraints?.maxDepth || 2;
         const queryEmbedding = await this.embeddingService.embed(query);
         const topk = limit * 2;
@@ -350,7 +371,7 @@ class HybridSearch {
         // 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
+      rank_val[id, r] := *entity{id}, not *entity_rank{entity_id: id}, r = 0.0
 
       seeds[id, score] := ${seedConstraints.join(", ")}, score = 1.0 - dist
       
@@ -360,7 +381,7 @@ class HybridSearch {
 
       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, @ "NOW"}, source = 'graph_rag_entity', text = ''
+      ?[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
@@ -396,19 +417,31 @@ class HybridSearch {
             }
             const decayedResults = this.applyTimeDecay(searchResults);
             if (options.rerank) {
-                return await this.applyReranking(options.query, decayedResults);
+                const reranked = await this.applyReranking(options.query, decayedResults);
+                endTimer();
+                return reranked;
             }
+            endTimer();
             return decayedResults;
         }
         catch (e) {
-            console.error("[HybridSearch] Error in graphRag:", e.message);
-            // Fallback to normal search on error
-            return this.search(options);
+            logger_1.logger.error('HybridSearch', 'Error in graphRag', e.message);
+            performance_monitor_1.perfMonitor.recordMetric('graphRag', 0, true);
+            endTimer();
+            // Prevent infinite recursion by returning empty results
+            logger_1.logger.warn('HybridSearch', 'Returning empty results to prevent infinite loop');
+            return [];
         }
     }
     async agenticRetrieve(options) {
-        console.error("[HybridSearch] Starting agenticRetrieve with query:", options.query);
+        logger_1.logger.debug('HybridSearch', 'Starting agenticRetrieve', { query: options.query });
         const { query, routingModel = "demyagent-4b-i1:Q6_K" } = options;
+        // Validate limit to prevent infinite loops
+        if (options.limit !== undefined && options.limit <= 0) {
+            logger_1.logger.warn('HybridSearch', `Invalid limit value: ${options.limit} - must be positive. Defaulting to 10.`);
+            options.limit = 10;
+        }
+        const endTimer = performance_monitor_1.perfMonitor.startTimer('agenticRetrieve');
         const systemPrompt = `You are a Routing Agent for an advanced Memory/RAG system.
 Your job is to analyze the user's query and decide which search strategy is the most appropriate.
 Available strategies: