cozo-memory 1.1.7 → 1.2.0

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/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:

package/dist/logger.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Centralized Logging System for CozoDB Memory
+ *
+ * Supports different log levels and can be configured via environment variables
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+    LogLevel[LogLevel["TRACE"] = 4] = "TRACE";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));
+class Logger {
+    level;
+    prefix;
+    constructor(prefix = '[CozoDB]') {
+        this.prefix = prefix;
+        // Read from environment variable, default to INFO
+        const envLevel = process.env.LOG_LEVEL?.toUpperCase();
+        this.level = LogLevel[envLevel] ?? LogLevel.INFO;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    error(component, message, ...args) {
+        if (this.level >= LogLevel.ERROR) {
+            console.error(`${this.prefix}[${component}] ERROR:`, message, ...args);
+        }
+    }
+    warn(component, message, ...args) {
+        if (this.level >= LogLevel.WARN) {
+            console.warn(`${this.prefix}[${component}] WARN:`, message, ...args);
+        }
+    }
+    info(component, message, ...args) {
+        if (this.level >= LogLevel.INFO) {
+            console.error(`${this.prefix}[${component}] INFO:`, message, ...args);
+        }
+    }
+    debug(component, message, ...args) {
+        if (this.level >= LogLevel.DEBUG) {
+            console.error(`${this.prefix}[${component}] DEBUG:`, message, ...args);
+        }
+    }
+    trace(component, message, ...args) {
+        if (this.level >= LogLevel.TRACE) {
+            console.error(`${this.prefix}[${component}] TRACE:`, message, ...args);
+        }
+    }
+}
+// Singleton instance
+exports.logger = new Logger();

package/dist/migrate-logging.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * Migration Script: Replace console.error with logger
+ *
+ * This script helps migrate from console.error to the centralized logger
+ */
+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 });
+const fs = __importStar(require("fs"));
+const filesToMigrate = [
+    'src/memory-service.ts',
+    'src/db-service.ts',
+    'src/embedding-service.ts',
+    'src/inference-engine.ts',
+    'src/dynamic-fusion.ts',
+    'src/adaptive-retrieval.ts',
+    'src/adaptive-query-fusion.ts',
+    'src/reranker-service.ts',
+    'src/export-import-service.ts',
+    'src/janitor-service.ts'
+];
+// Mapping of console.error patterns to logger calls
+const migrations = [
+    {
+        pattern: /console\.error\(\s*\[([^\]]+)\]\s+([^,]+),/g,
+        replacement: "logger.error('$1', $2,"
+    },
+    {
+        pattern: /console\.error\(\s*\[([^\]]+)\]\s+([^)]+)\)/g,
+        replacement: "logger.error('$1', $2)"
+    },
+    {
+        pattern: /console\.warn\(\s*\[([^\]]+)\]\s+([^)]+)\)/g,
+        replacement: "logger.warn('$1', $2)"
+    }
+];
+function migrateFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+        console.log(`Skipping ${filePath} - file not found`);
+        return;
+    }
+    let content = fs.readFileSync(filePath, 'utf-8');
+    let modified = false;
+    // Check if logger is already imported
+    if (!content.includes("import { logger }")) {
+        // Find the last import statement
+        const importRegex = /^import .+ from .+;$/gm;
+        const imports = content.match(importRegex);
+        if (imports && imports.length > 0) {
+            const lastImport = imports[imports.length - 1];
+            const lastImportIndex = content.lastIndexOf(lastImport);
+            content = content.slice(0, lastImportIndex + lastImport.length) +
+                "\nimport { logger } from './logger';" +
+                content.slice(lastImportIndex + lastImport.length);
+            modified = true;
+        }
+    }
+    // Apply migrations
+    for (const migration of migrations) {
+        if (migration.pattern.test(content)) {
+            content = content.replace(migration.pattern, migration.replacement);
+            modified = true;
+        }
+    }
+    if (modified) {
+        fs.writeFileSync(filePath, content, 'utf-8');
+        console.log(`✓ Migrated ${filePath}`);
+    }
+    else {
+        console.log(`- No changes needed for ${filePath}`);
+    }
+}
+console.log('Starting logging migration...\n');
+for (const file of filesToMigrate) {
+    migrateFile(file);
+}
+console.log('\nMigration complete!');
+console.log('\nNext steps:');
+console.log('1. Review the changes');
+console.log('2. Run: npm run build');
+console.log('3. Test with: LOG_LEVEL=DEBUG npm start');

package/dist/performance-monitor.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Performance Monitoring System
+ *
+ * Tracks operation latencies, throughput, and resource usage
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.perfMonitor = exports.PerformanceMonitor = void 0;
+const logger_1 = require("./logger");
+class PerformanceMonitor {
+    metrics;
+    maxSamples;
+    constructor(maxSamples = 1000) {
+        this.metrics = new Map();
+        this.maxSamples = maxSamples;
+    }
+    /**
+     * Start timing an operation
+     */
+    startTimer(operation) {
+        const startTime = Date.now();
+        return () => {
+            const duration = Date.now() - startTime;
+            this.recordMetric(operation, duration);
+        };
+    }
+    /**
+     * Record a metric manually
+     */
+    recordMetric(operation, duration, isError = false) {
+        let metric = this.metrics.get(operation);
+        if (!metric) {
+            metric = {
+                times: [],
+                errors: 0,
+                lastExecuted: Date.now()
+            };
+            this.metrics.set(operation, metric);
+        }
+        metric.times.push(duration);
+        metric.lastExecuted = Date.now();
+        if (isError) {
+            metric.errors++;
+        }
+        // Keep only last N samples
+        if (metric.times.length > this.maxSamples) {
+            metric.times.shift();
+        }
+    }
+    /**
+     * Get metrics for a specific operation
+     */
+    getMetrics(operation) {
+        const metric = this.metrics.get(operation);
+        if (!metric || metric.times.length === 0) {
+            return null;
+        }
+        const sorted = [...metric.times].sort((a, b) => a - b);
+        const count = sorted.length;
+        const totalTime = sorted.reduce((sum, t) => sum + t, 0);
+        return {
+            operation,
+            count,
+            totalTime,
+            avgTime: totalTime / count,
+            minTime: sorted[0],
+            maxTime: sorted[count - 1],
+            p50: sorted[Math.floor(count * 0.5)],
+            p95: sorted[Math.floor(count * 0.95)],
+            p99: sorted[Math.floor(count * 0.99)],
+            errors: metric.errors,
+            lastExecuted: metric.lastExecuted
+        };
+    }
+    /**
+     * Get all metrics
+     */
+    getAllMetrics() {
+        const results = [];
+        for (const operation of this.metrics.keys()) {
+            const metric = this.getMetrics(operation);
+            if (metric) {
+                results.push(metric);
+            }
+        }
+        return results.sort((a, b) => b.count - a.count);
+    }
+    /**
+     * Log performance summary
+     */
+    logSummary() {
+        const metrics = this.getAllMetrics();
+        logger_1.logger.info('PerformanceMonitor', '=== Performance Summary ===');
+        for (const m of metrics) {
+            logger_1.logger.info('PerformanceMonitor', `${m.operation}: ${m.count} calls, avg=${m.avgTime.toFixed(2)}ms, ` +
+                `p95=${m.p95.toFixed(2)}ms, errors=${m.errors}`);
+        }
+    }
+    /**
+     * Reset all metrics
+     */
+    reset() {
+        this.metrics.clear();
+    }
+}
+exports.PerformanceMonitor = PerformanceMonitor;
+// Singleton instance
+exports.perfMonitor = new PerformanceMonitor();