myavana-bot-test-core 2.1.7 → 2.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "myavana-bot-test-core",
-    "version": "2.1.7",
+    "version": "2.1.9",
     "description": "Shared bot functionality with enhanced features",
     "main": "index.js",
     "scripts": {

package/src/cacheManager.js

@@ -1,24 +1,88 @@
-// cacheManager.js
+// cacheManager.js - OPTIMIZED VERSION
 
 const ai = require('./ai');
 const { googleAI } = require('@genkit-ai/google-genai');
 const { pgClient, redisClient } = require('./database');
-const  {GoogleGenAI} = require("@google/genai");
+const { GoogleGenAI } = require("@google/genai");
 const config = require('./config');
 
 /**
  * Cache Manager for Gemini API
  * Handles creation, retrieval, and expiration of cached system instructions
+ * OPTIMIZED: Check cache validity before expensive prompt construction
  */
 const cacheAi = new GoogleGenAI({ apiKey: config.genkitApiKey });
+
 class CacheManager {
     constructor() {
         this.CACHE_TTL_HOURS = 24;
         this.CACHE_TTL_SECONDS = this.CACHE_TTL_HOURS * 60 * 60; // 24 hours in seconds
+        this.CACHE_REFRESH_THRESHOLD_HOURS = 1; // Refresh if cache expires in < 1 hour
+    }
+
+    /**
+     * NEW: Check if user has a valid cache WITHOUT constructing prompt
+     * This is fast and should be called BEFORE expensive prompt construction
+     * @param {string} userId - User identifier
+     * @returns {Promise<{hasValidCache: boolean, cacheName: string|null, needsRefresh: boolean}>}
+     */
+    async checkCacheValidity(userId) {
+        console.log('🔍 Quick cache check for user:', userId);
+        
+        try {
+            const existingCache = await this.getUserCache(userId);
+            
+            if (!existingCache) {
+                console.log('📭 No cache exists - will need to create one');
+                return {
+                    hasValidCache: false,
+                    cacheName: null,
+                    needsRefresh: false,
+                    reason: 'no_cache'
+                };
+            }
+            
+            if (this.isCacheExpired(existingCache)) {
+                console.log('⏰ Cache expired - will need to create new one');
+                return {
+                    hasValidCache: false,
+                    cacheName: null,
+                    needsRefresh: true,
+                    reason: 'expired'
+                };
+            }
+            
+            const remainingHours = this.getCacheRemainingHours(existingCache);
+            const needsRefresh = remainingHours < this.CACHE_REFRESH_THRESHOLD_HOURS;
+            
+            console.log('✅ Valid cache found:', {
+                cacheName: existingCache.cache_name,
+                remainingHours: remainingHours,
+                needsRefresh: needsRefresh
+            });
+            
+            return {
+                hasValidCache: true,
+                cacheName: existingCache.cache_name,
+                needsRefresh: needsRefresh,
+                remainingHours: remainingHours,
+                reason: 'valid'
+            };
+            
+        } catch (error) {
+            console.error('❌ Cache check failed:', error.message);
+            return {
+                hasValidCache: false,
+                cacheName: null,
+                needsRefresh: false,
+                reason: 'error'
+            };
+        }
     }
 
     /**
      * Get or create a cache for a user's system prompt
+     * NOW: Can be called conditionally based on checkCacheValidity result
      * @param {string} userId - User identifier
      * @param {string} systemPrompt - The large system instruction to cache
      * @returns {Promise<{cacheName: string, isNewCache: boolean}>}
@@ -54,9 +118,10 @@ class CacheManager {
             // Create new cache
             console.log('🆕 Creating new cache for user:', userId);
             const cacheStartTime = performance.now();
+            const modelName = "gemini-3-flash-preview";
             
             const cache = await cacheAi.caches.create({
-                model: googleAI.model('gemini-3-flash-preview'),
+                model: modelName,
                 config: {
                     systemInstruction: systemPrompt,
                 },
@@ -100,6 +165,7 @@ class CacheManager {
 
     /**
      * Get user's cache info from database
+     * FIXED: Using correct PostgreSQL syntax (not MySQL)
      * @param {string} userId 
      * @returns {Promise<object|null>}
      */
@@ -110,20 +176,20 @@ class CacheManager {
             const query = `
                 SELECT cache_name, created_at, expires_at 
                 FROM user_gemini_caches 
-                WHERE user_id = ? 
+                WHERE user_id = $1 
                 ORDER BY created_at DESC 
                 LIMIT 1
             `;
             
             const result = await pgClient.query(query, [userId]);
             
-            if (result && result.length > 0) {
+            if (result && result.rows && result.rows.length > 0) {
                 console.log('✅ Found existing cache record:', {
-                    cacheName: result[0].cache_name,
-                    createdAt: result[0].created_at,
-                    expiresAt: result[0].expires_at
+                    cacheName: result.rows[0].cache_name,
+                    createdAt: result.rows[0].created_at,
+                    expiresAt: result.rows[0].expires_at
                 });
-                return result[0];
+                return result.rows[0];
             }
             
             console.log('📭 No existing cache found for user');
@@ -137,6 +203,7 @@ class CacheManager {
 
     /**
      * Save cache info to database
+     * FIXED: Using PostgreSQL syntax instead of MySQL
      * @param {string} userId 
      * @param {string} cacheName 
      */
@@ -149,14 +216,16 @@ class CacheManager {
         try {
             const expiresAt = new Date(Date.now() + this.CACHE_TTL_SECONDS * 1000);
             
+            // PostgreSQL syntax with UPSERT (ON CONFLICT)
             const query = `
                 INSERT INTO user_gemini_caches 
-                (user_id, cache_name, created_at, expires_at) 
-                VALUES (?, ?, NOW(), ?)
-                ON DUPLICATE KEY UPDATE 
-                    cache_name = VALUES(cache_name),
+                    (user_id, cache_name, created_at, expires_at) 
+                VALUES ($1, $2, NOW(), $3)
+                ON CONFLICT (user_id) 
+                DO UPDATE SET 
+                    cache_name = EXCLUDED.cache_name,
                     created_at = NOW(),
-                    expires_at = VALUES(expires_at)
+                    expires_at = EXCLUDED.expires_at
             `;
             
             await pgClient.query(query, [userId, cacheName, expiresAt]);
@@ -165,6 +234,7 @@ class CacheManager {
             
         } catch (error) {
             console.error('❌ Failed to save cache info:', error.message);
+            console.error('❌ Error details:', error);
             // Don't throw - cache creation succeeded, DB save is secondary
         }
     }
@@ -200,7 +270,7 @@ class CacheManager {
         const now = new Date();
         const createdAt = new Date(cacheRecord.created_at);
         const ageMs = now - createdAt;
-        return (ageMs / (1000 * 60 * 60)).toFixed(2);
+        return parseFloat((ageMs / (1000 * 60 * 60)).toFixed(2));
     }
 
     /**
@@ -212,11 +282,12 @@ class CacheManager {
         const now = new Date();
         const expiresAt = new Date(cacheRecord.expires_at);
         const remainingMs = expiresAt - now;
-        return Math.max(0, (remainingMs / (1000 * 60 * 60)).toFixed(2));
+        return Math.max(0, parseFloat((remainingMs / (1000 * 60 * 60)).toFixed(2)));
     }
 
     /**
      * Clean up expired caches from database (maintenance task)
+     * FIXED: PostgreSQL syntax
      */
     async cleanupExpiredCaches() {
         console.log('🧹 Cleaning up expired caches...');
@@ -230,7 +301,7 @@ class CacheManager {
             const result = await pgClient.query(query);
             
             console.log('✅ Cleanup complete:', {
-                deletedRecords: result.affectedRows || 0
+                deletedRecords: result.rowCount || 0
             });
             
         } catch (error) {
@@ -240,6 +311,7 @@ class CacheManager {
 
     /**
      * Get cache statistics for monitoring
+     * FIXED: PostgreSQL syntax with EXTRACT instead of TIMESTAMPDIFF
      */
     async getCacheStats() {
         try {
@@ -248,18 +320,43 @@ class CacheManager {
                     COUNT(*) as total_caches,
                     COUNT(CASE WHEN expires_at > NOW() THEN 1 END) as active_caches,
                     COUNT(CASE WHEN expires_at <= NOW() THEN 1 END) as expired_caches,
-                    AVG(TIMESTAMPDIFF(HOUR, created_at, NOW())) as avg_age_hours
+                    AVG(EXTRACT(EPOCH FROM (NOW() - created_at)) / 3600) as avg_age_hours
                 FROM user_gemini_caches
             `;
             
             const result = await pgClient.query(query);
-            return result[0];
+            return result.rows[0];
             
         } catch (error) {
             console.error('❌ Failed to get cache stats:', error.message);
             return null;
         }
     }
+
+    /**
+     * NEW: Proactively refresh cache in background if it's about to expire
+     * This ensures users always have a fresh cache without waiting
+     * @param {string} userId 
+     * @param {function} getSystemPromptFn - Function that returns the system prompt
+     */
+    async refreshCacheIfNeeded(userId, getSystemPromptFn) {
+        const cacheStatus = await this.checkCacheValidity(userId);
+        
+        if (cacheStatus.needsRefresh) {
+            console.log('🔄 Cache needs refresh - starting background refresh');
+            
+            // Do this asynchronously - don't wait
+            setImmediate(async () => {
+                try {
+                    const systemPrompt = await getSystemPromptFn();
+                    await this.getOrCreateCache(userId, systemPrompt);
+                    console.log('✅ Background cache refresh completed');
+                } catch (error) {
+                    console.error('❌ Background cache refresh failed:', error.message);
+                }
+            });
+        }
+    }
 }
 
 module.exports = new CacheManager();