myavana-bot-test-core 2.1.4 → 2.1.6

package/index.js

@@ -1,5 +1,6 @@
 // packages/core/index.js - Fixed exports with proper module loading
 const path = require('path');
+const cacheManager = require('./src/cacheManager');
 
 // Helper function to safely load modules
 function safeRequire(modulePath, moduleName) {
@@ -28,6 +29,8 @@ const modules = {
     // AI and session management
     ai: safeRequire('./src/ai', 'ai'),
     DatabaseSessionStore: safeRequire('./src/session', 'DatabaseSessionStore'),
+    cacheManager: safeRequire('./src/cacheManager', 'cacheManager'),
+    
   
     // User and conversation management
     getUserDetails: safeRequire('./src/user', 'user')?.getUserDetails,

package/package.json

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

package/setup-cache-maintenance.sh

@@ -0,0 +1,126 @@
+#!/bin/bash
+# setup-cache-maintenance.sh
+# Sets up automated cache maintenance via cron
+
+echo "🔧 Setting up Gemini Cache Maintenance"
+echo "======================================"
+
+# Get the directory where this script is located
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+MAINTENANCE_SCRIPT="$SCRIPT_DIR/cacheMaintenanceScript.js"
+LOG_DIR="$SCRIPT_DIR/logs"
+LOG_FILE="$LOG_DIR/cache-maintenance.log"
+
+# Check if Node.js is installed
+if ! command -v node &> /dev/null; then
+    echo "❌ Error: Node.js is not installed"
+    echo "Please install Node.js first: https://nodejs.org/"
+    exit 1
+fi
+
+echo "✅ Node.js found: $(node --version)"
+
+# Check if maintenance script exists
+if [ ! -f "$MAINTENANCE_SCRIPT" ]; then
+    echo "❌ Error: Maintenance script not found at $MAINTENANCE_SCRIPT"
+    exit 1
+fi
+
+echo "✅ Maintenance script found"
+
+# Create logs directory if it doesn't exist
+if [ ! -d "$LOG_DIR" ]; then
+    mkdir -p "$LOG_DIR"
+    echo "✅ Created logs directory: $LOG_DIR"
+else
+    echo "✅ Logs directory exists: $LOG_DIR"
+fi
+
+# Create log file if it doesn't exist
+touch "$LOG_FILE"
+echo "✅ Log file ready: $LOG_FILE"
+
+# Test the maintenance script
+echo ""
+echo "🧪 Testing maintenance script..."
+node "$MAINTENANCE_SCRIPT"
+
+if [ $? -eq 0 ]; then
+    echo "✅ Maintenance script test successful"
+else
+    echo "❌ Maintenance script test failed"
+    echo "Please check the script for errors before setting up cron"
+    exit 1
+fi
+
+# Generate cron job entry
+CRON_ENTRY="0 2 * * * /usr/bin/node $MAINTENANCE_SCRIPT >> $LOG_FILE 2>&1"
+
+echo ""
+echo "📋 Cron Job Configuration"
+echo "========================="
+echo "Schedule: Daily at 2:00 AM"
+echo "Script: $MAINTENANCE_SCRIPT"
+echo "Log: $LOG_FILE"
+echo ""
+echo "Cron entry:"
+echo "$CRON_ENTRY"
+echo ""
+
+# Ask user if they want to add to crontab
+read -p "Do you want to add this to your crontab? (y/n) " -n 1 -r
+echo
+if [[ $REPLY =~ ^[Yy]$ ]]; then
+    # Check if cron entry already exists
+    if crontab -l 2>/dev/null | grep -q "$MAINTENANCE_SCRIPT"; then
+        echo "⚠️ Cron job already exists for this script"
+        read -p "Do you want to remove the old entry and add a new one? (y/n) " -n 1 -r
+        echo
+        if [[ $REPLY =~ ^[Yy]$ ]]; then
+            # Remove old entries
+            crontab -l 2>/dev/null | grep -v "$MAINTENANCE_SCRIPT" | crontab -
+            echo "✅ Removed old cron entry"
+        else
+            echo "❌ Setup cancelled"
+            exit 0
+        fi
+    fi
+    
+    # Add new cron entry
+    (crontab -l 2>/dev/null; echo "$CRON_ENTRY") | crontab -
+    
+    if [ $? -eq 0 ]; then
+        echo "✅ Cron job added successfully!"
+        echo ""
+        echo "Current crontab:"
+        crontab -l | grep "$MAINTENANCE_SCRIPT"
+    else
+        echo "❌ Failed to add cron job"
+        exit 1
+    fi
+else
+    echo "ℹ️ Cron job not added"
+    echo ""
+    echo "To add manually, run:"
+    echo "crontab -e"
+    echo ""
+    echo "Then add this line:"
+    echo "$CRON_ENTRY"
+fi
+
+echo ""
+echo "🎉 Setup Complete!"
+echo ""
+echo "📖 Next Steps:"
+echo "1. Monitor logs: tail -f $LOG_FILE"
+echo "2. Test manually: node $MAINTENANCE_SCRIPT"
+echo "3. View cron jobs: crontab -l"
+echo "4. Edit cron schedule: crontab -e"
+echo ""
+echo "⏰ Schedule Options:"
+echo "Daily at 2 AM:      0 2 * * *"
+echo "Every 12 hours:     0 */12 * * *"
+echo "Every 6 hours:      0 */6 * * *"
+echo "Hourly:             0 * * * *"
+echo ""
+echo "To change schedule: crontab -e"

package/src/ai.js

@@ -1,5 +1,5 @@
 // ai.js
-const { genkit } = require('genkit');
+const { genkit } = require('genkit/beta');
 const { googleAI } = require('@genkit-ai/google-genai');
 
 const config = require('./config');

package/src/cacheMaintenanceScript.js

@@ -0,0 +1,256 @@
+// cacheMaintenanceScript.js
+// Run this script daily via cron to cleanup expired caches and monitor cache health
+
+const cacheManager = require('./cacheManager');
+const { pgClient, redisClient } = require('./database');
+
+/**
+ * Comprehensive cache maintenance and monitoring script
+ */
+async function runMaintenance() {
+    console.log('🧹 ===== CACHE MAINTENANCE SCRIPT START =====');
+    console.log('📅 Timestamp:', new Date().toISOString());
+    
+    try {
+        
+        if (!pgClient) {
+            throw new Error('Database connection not available');
+        }
+        
+        console.log('✅ Database connection established');
+        
+        // Step 1: Get cache statistics BEFORE cleanup
+        console.log('\n📊 ===== PRE-CLEANUP STATISTICS =====');
+        const preStats = await cacheManager.getCacheStats();
+        
+        if (preStats) {
+            console.log('Cache Statistics:', {
+                totalCaches: preStats.total_caches,
+                activeCaches: preStats.active_caches,
+                expiredCaches: preStats.expired_caches,
+                avgAgeHours: parseFloat(preStats.avg_age_hours).toFixed(2),
+                hitRate: preStats.active_caches > 0 
+                    ? ((preStats.active_caches / preStats.total_caches) * 100).toFixed(2) + '%'
+                    : 'N/A'
+            });
+        } else {
+            console.log('⚠️ Could not retrieve cache statistics');
+        }
+        
+        // Step 2: Cleanup expired caches
+        console.log('\n🧹 ===== CLEANING UP EXPIRED CACHES =====');
+        const cleanupStartTime = Date.now();
+        await cacheManager.cleanupExpiredCaches();
+        const cleanupTime = Date.now() - cleanupStartTime;
+        console.log(`✅ Cleanup completed in ${cleanupTime}ms`);
+        
+        // Step 3: Get cache statistics AFTER cleanup
+        console.log('\n📊 ===== POST-CLEANUP STATISTICS =====');
+        const postStats = await cacheManager.getCacheStats();
+        
+        if (postStats) {
+            console.log('Updated Cache Statistics:', {
+                totalCaches: postStats.total_caches,
+                activeCaches: postStats.active_caches,
+                expiredCaches: postStats.expired_caches,
+                avgAgeHours: parseFloat(postStats.avg_age_hours).toFixed(2),
+                hitRate: postStats.active_caches > 0 
+                    ? ((postStats.active_caches / postStats.total_caches) * 100).toFixed(2) + '%'
+                    : 'N/A'
+            });
+            
+            // Calculate cleanup impact
+            if (preStats) {
+                const recordsRemoved = preStats.total_caches - postStats.total_caches;
+                console.log('\n📈 Cleanup Impact:', {
+                    recordsRemoved: recordsRemoved,
+                    percentageRemoved: preStats.total_caches > 0 
+                        ? ((recordsRemoved / preStats.total_caches) * 100).toFixed(2) + '%'
+                        : '0%'
+                });
+            }
+        }
+        
+        // Step 4: Get cache age distribution
+        console.log('\n📊 ===== CACHE AGE DISTRIBUTION =====');
+        const ageDistribution = await getCacheAgeDistribution();
+        if (ageDistribution) {
+            console.log('Age Distribution:', ageDistribution);
+        }
+        
+        // Step 5: Identify users with stale or missing caches
+        console.log('\n🔍 ===== CACHE HEALTH CHECK =====');
+        const healthCheck = await performCacheHealthCheck();
+        if (healthCheck) {
+            console.log('Health Check Results:', healthCheck);
+        }
+        
+        // Step 6: Generate recommendations
+        console.log('\n💡 ===== RECOMMENDATIONS =====');
+        generateRecommendations(preStats, postStats);
+        
+        console.log('\n✅ ===== CACHE MAINTENANCE COMPLETE =====');
+        console.log('📅 Completed at:', new Date().toISOString());
+        
+        // Close database connection if needed
+        
+        process.exit(0);
+        
+    } catch (error) {
+        console.error('\n❌ ===== MAINTENANCE SCRIPT FAILED =====');
+        console.error('Error:', {
+            message: error.message,
+            stack: error.stack,
+            timestamp: new Date().toISOString()
+        });
+        
+        process.exit(1);
+    }
+}
+
+/**
+ * Get cache age distribution
+ */
+async function getCacheAgeDistribution() {
+    try {
+        const query = `
+            SELECT 
+                CASE 
+                    WHEN TIMESTAMPDIFF(HOUR, created_at, NOW()) < 6 THEN '0-6 hours'
+                    WHEN TIMESTAMPDIFF(HOUR, created_at, NOW()) < 12 THEN '6-12 hours'
+                    WHEN TIMESTAMPDIFF(HOUR, created_at, NOW()) < 18 THEN '12-18 hours'
+                    WHEN TIMESTAMPDIFF(HOUR, created_at, NOW()) < 24 THEN '18-24 hours'
+                    ELSE '24+ hours (expired)'
+                END as age_range,
+                COUNT(*) as count
+            FROM user_gemini_caches
+            WHERE expires_at > NOW()
+            GROUP BY age_range
+            ORDER BY MIN(TIMESTAMPDIFF(HOUR, created_at, NOW()))
+        `;
+        
+        const result = await pgClient.query(query);
+        return result;
+        
+    } catch (error) {
+        console.error('Failed to get age distribution:', error.message);
+        return null;
+    }
+}
+
+/**
+ * Perform cache health check
+ */
+async function performCacheHealthCheck() {
+    try {
+        // Check for users with very old caches (approaching expiration)
+        const expiringQuery = `
+            SELECT user_id, cache_name, 
+                   TIMESTAMPDIFF(HOUR, NOW(), expires_at) as hours_until_expiration
+            FROM user_gemini_caches
+            WHERE expires_at > NOW() 
+            AND TIMESTAMPDIFF(HOUR, NOW(), expires_at) < 2
+            LIMIT 10
+        `;
+        
+        const expiringSoon = await pgClient.query(expiringQuery);
+        
+        // Get total unique users who have used chat
+        const totalUsersQuery = `
+            SELECT COUNT(DISTINCT user_id) as total_users
+            FROM user_gemini_caches
+        `;
+        
+        const totalUsersResult = await pgClient.query(totalUsersQuery);
+        const totalUsers = totalUsersResult[0].total_users;
+        
+        // Get active cache count
+        const activeCacheQuery = `
+            SELECT COUNT(*) as active_count
+            FROM user_gemini_caches
+            WHERE expires_at > NOW()
+        `;
+        
+        const activeCacheResult = await pgClient.query(activeCacheQuery);
+        const activeCaches = activeCacheResult[0].active_count;
+        
+        return {
+            totalUsers: totalUsers,
+            usersWithActiveCache: activeCaches,
+            cacheHitPotential: totalUsers > 0 
+                ? ((activeCaches / totalUsers) * 100).toFixed(2) + '%'
+                : 'N/A',
+            cachesExpiringSoon: expiringSoon.length,
+            expiringSoonDetails: expiringSoon.slice(0, 3) // Show first 3
+        };
+        
+    } catch (error) {
+        console.error('Health check failed:', error.message);
+        return null;
+    }
+}
+
+/**
+ * Generate recommendations based on statistics
+ */
+function generateRecommendations(preStats, postStats) {
+    const recommendations = [];
+    
+    if (!postStats) {
+        console.log('⚠️ Cannot generate recommendations without statistics');
+        return;
+    }
+    
+    // Check cache hit rate
+    const hitRate = postStats.active_caches > 0 
+        ? (postStats.active_caches / postStats.total_caches) * 100
+        : 0;
+    
+    if (hitRate < 50) {
+        recommendations.push('⚠️ Low cache hit rate (<50%). Consider:');
+        recommendations.push('   - Investigating why caches are expiring quickly');
+        recommendations.push('   - Checking if TTL needs adjustment');
+    } else if (hitRate > 80) {
+        recommendations.push('✅ Excellent cache hit rate (>80%)!');
+    }
+    
+    // Check average age
+    const avgAge = parseFloat(postStats.avg_age_hours);
+    if (avgAge < 6) {
+        recommendations.push('⚠️ Low average cache age (<6 hours). Consider:');
+        recommendations.push('   - Checking if caches are being invalidated prematurely');
+        recommendations.push('   - Verifying system time is correct');
+    }
+    
+    // Check total cache count
+    if (postStats.total_caches < 10) {
+        recommendations.push('ℹ️ Low total cache count. This is normal for new deployments.');
+    } else if (postStats.total_caches > 10000) {
+        recommendations.push('⚠️ High cache count (>10k). Consider:');
+        recommendations.push('   - More frequent cleanup runs');
+        recommendations.push('   - Adding database indexes for performance');
+    }
+    
+    // Check cleanup effectiveness
+    if (preStats && postStats) {
+        const recordsRemoved = preStats.total_caches - postStats.total_caches;
+        if (recordsRemoved === 0 && preStats.expired_caches > 0) {
+            recommendations.push('⚠️ Cleanup ran but removed no records. Check cleanup logic.');
+        } else if (recordsRemoved > 0) {
+            recommendations.push(`✅ Cleanup successfully removed ${recordsRemoved} expired records.`);
+        }
+    }
+    
+    if (recommendations.length === 0) {
+        console.log('✅ All systems normal. No recommendations.');
+    } else {
+        recommendations.forEach(rec => console.log(rec));
+    }
+}
+
+// Run the maintenance script
+if (require.main === module) {
+    runMaintenance();
+}
+
+module.exports = { runMaintenance };

package/src/cacheManager.js

@@ -0,0 +1,262 @@
+// cacheManager.js
+
+const ai = require('./ai');
+const { googleAI } = require('@genkit-ai/google-genai');
+const { pgClient, redisClient } = require('./database');
+
+/**
+ * Cache Manager for Gemini API
+ * Handles creation, retrieval, and expiration of cached system instructions
+ */
+class CacheManager {
+    constructor() {
+        this.CACHE_TTL_HOURS = 24;
+        this.CACHE_TTL_SECONDS = this.CACHE_TTL_HOURS * 60 * 60; // 24 hours in seconds
+    }
+
+    /**
+     * Get or create a cache for a user's system prompt
+     * @param {string} userId - User identifier
+     * @param {string} systemPrompt - The large system instruction to cache
+     * @returns {Promise<{cacheName: string, isNewCache: boolean}>}
+     */
+    async getOrCreateCache(userId, systemPrompt) {
+        console.log('🔍 ===== CACHE MANAGER: GET OR CREATE =====');
+        console.log('📊 Cache Request:', {
+            userId: userId,
+            systemPromptLength: systemPrompt.length,
+            estimatedTokens: Math.ceil(systemPrompt.length / 4),
+            timestamp: new Date().toISOString()
+        });
+
+        try {
+            // Try to get existing cache for user
+            const existingCache = await this.getUserCache(userId);
+            
+            if (existingCache && !this.isCacheExpired(existingCache)) {
+                console.log('✅ Using existing cache:', {
+                    cacheName: existingCache.cache_name,
+                    createdAt: existingCache.created_at,
+                    expiresAt: existingCache.expires_at,
+                    ageHours: this.getCacheAgeHours(existingCache),
+                    remainingHours: this.getCacheRemainingHours(existingCache)
+                });
+                
+                return {
+                    cacheName: existingCache.cache_name,
+                    isNewCache: false
+                };
+            }
+
+            // Create new cache
+            console.log('🆕 Creating new cache for user:', userId);
+            const cacheStartTime = performance.now();
+            
+            const cache = await ai.caches.create({
+                model: googleAI.model('gemini-3-flash-preview'),
+                config: {
+                    systemInstruction: systemPrompt,
+                },
+                ttlSeconds: this.CACHE_TTL_SECONDS
+            });
+
+            const cacheCreationTime = performance.now() - cacheStartTime;
+            console.log('✅ Cache created successfully:', {
+                cacheName: cache.name,
+                creationTime: cacheCreationTime.toFixed(2) + 'ms',
+                ttlHours: this.CACHE_TTL_HOURS,
+                expiresAt: new Date(Date.now() + this.CACHE_TTL_SECONDS * 1000).toISOString()
+            });
+
+            // Save cache info to database
+            await this.saveUserCache(userId, cache.name);
+            
+            console.log('💾 Cache info saved to database');
+            console.log('🔍 ===== CACHE MANAGER: COMPLETE =====');
+
+            return {
+                cacheName: cache.name,
+                isNewCache: true
+            };
+
+        } catch (error) {
+            console.error('❌ Cache creation/retrieval failed:', {
+                error: error.message,
+                userId: userId,
+                timestamp: new Date().toISOString()
+            });
+            
+            // Return null to indicate cache unavailable - caller should proceed without cache
+            return {
+                cacheName: null,
+                isNewCache: false,
+                error: error.message
+            };
+        }
+    }
+
+    /**
+     * Get user's cache info from database
+     * @param {string} userId 
+     * @returns {Promise<object|null>}
+     */
+    async getUserCache(userId) {
+        console.log('📂 Fetching cache info from database for user:', userId);
+        
+        try {
+            const query = `
+                SELECT cache_name, created_at, expires_at 
+                FROM user_gemini_caches 
+                WHERE user_id = ? 
+                ORDER BY created_at DESC 
+                LIMIT 1
+            `;
+            
+            const result = await pgClient.query(query, [userId]);
+            
+            if (result && result.length > 0) {
+                console.log('✅ Found existing cache record:', {
+                    cacheName: result[0].cache_name,
+                    createdAt: result[0].created_at,
+                    expiresAt: result[0].expires_at
+                });
+                return result[0];
+            }
+            
+            console.log('📭 No existing cache found for user');
+            return null;
+            
+        } catch (error) {
+            console.error('❌ Database query failed:', error.message);
+            return null;
+        }
+    }
+
+    /**
+     * Save cache info to database
+     * @param {string} userId 
+     * @param {string} cacheName 
+     */
+    async saveUserCache(userId, cacheName) {
+        console.log('💾 Saving cache info to database:', {
+            userId: userId,
+            cacheName: cacheName
+        });
+
+        try {
+            const expiresAt = new Date(Date.now() + this.CACHE_TTL_SECONDS * 1000);
+            
+            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),
+                    created_at = NOW(),
+                    expires_at = VALUES(expires_at)
+            `;
+            
+            await pgClient.query(query, [userId, cacheName, expiresAt]);
+            
+            console.log('✅ Cache info saved successfully');
+            
+        } catch (error) {
+            console.error('❌ Failed to save cache info:', error.message);
+            // Don't throw - cache creation succeeded, DB save is secondary
+        }
+    }
+
+    /**
+     * Check if cache is expired
+     * @param {object} cacheRecord 
+     * @returns {boolean}
+     */
+    isCacheExpired(cacheRecord) {
+        const now = new Date();
+        const expiresAt = new Date(cacheRecord.expires_at);
+        
+        const isExpired = now >= expiresAt;
+        
+        if (isExpired) {
+            console.log('⏰ Cache expired:', {
+                expiresAt: expiresAt.toISOString(),
+                now: now.toISOString(),
+                expiredBy: ((now - expiresAt) / (1000 * 60)).toFixed(2) + ' minutes'
+            });
+        }
+        
+        return isExpired;
+    }
+
+    /**
+     * Get cache age in hours
+     * @param {object} cacheRecord 
+     * @returns {number}
+     */
+    getCacheAgeHours(cacheRecord) {
+        const now = new Date();
+        const createdAt = new Date(cacheRecord.created_at);
+        const ageMs = now - createdAt;
+        return (ageMs / (1000 * 60 * 60)).toFixed(2);
+    }
+
+    /**
+     * Get remaining cache lifetime in hours
+     * @param {object} cacheRecord 
+     * @returns {number}
+     */
+    getCacheRemainingHours(cacheRecord) {
+        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));
+    }
+
+    /**
+     * Clean up expired caches from database (maintenance task)
+     */
+    async cleanupExpiredCaches() {
+        console.log('🧹 Cleaning up expired caches...');
+        
+        try {
+            const query = `
+                DELETE FROM user_gemini_caches 
+                WHERE expires_at < NOW()
+            `;
+            
+            const result = await pgClient.query(query);
+            
+            console.log('✅ Cleanup complete:', {
+                deletedRecords: result.affectedRows || 0
+            });
+            
+        } catch (error) {
+            console.error('❌ Cleanup failed:', error.message);
+        }
+    }
+
+    /**
+     * Get cache statistics for monitoring
+     */
+    async getCacheStats() {
+        try {
+            const query = `
+                SELECT 
+                    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
+                FROM user_gemini_caches
+            `;
+            
+            const result = await pgClient.query(query);
+            return result[0];
+            
+        } catch (error) {
+            console.error('❌ Failed to get cache stats:', error.message);
+            return null;
+        }
+    }
+}
+
+module.exports = new CacheManager();