myavana-bot-test-core 1.0.0

package/package.json

@@ -0,0 +1,16 @@
+{
+    "name": "myavana-bot-test-core",
+    "version": "1.0.0",
+    "description": "Shared bot functionality",
+    "main": "index.js",
+    "scripts": {
+      "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "dependencies": {
+      "@genkit-ai/googleai": "^0.9.12",
+      "dotenv": "^16.4.7",
+      "genkit": "^0.9.12",
+      "pg": "^8.13.1",
+      "redis": "^4.7.0"
+    }
+  }

package/src/ai.js

@@ -0,0 +1,13 @@
+// ai.js
+const { genkit } = require('genkit');
+const { googleAI, gemini15Flash, gemini20FlashExp } = require('@genkit-ai/googleai');
+const config = require('./config');
+
+const ai = genkit({
+    plugins: [googleAI({
+        apiKey: config.genkitApiKey,
+    })],
+    model: gemini20FlashExp,
+});
+
+module.exports = ai;

package/src/config.js

@@ -0,0 +1,26 @@
+// config.js
+require('dotenv').config();
+
+module.exports = {
+    dbConfig: {
+        host: process.env.DB_HOST,
+        user: process.env.DB_USER,
+        password: process.env.DB_PASSWORD,
+        database: process.env.DB_NAME,
+        port: parseInt(process.env.DB_PORT, 10) || 5432, // Default PostgreSQL port
+    },
+    redisConfig: {
+        username: process.env.REDIS_USERNAME,
+        password: process.env.REDIS_PASSWORD,
+        socket: {
+            host: process.env.REDIS_HOST,
+            port: parseInt(process.env.REDIS_PORT, 10) || 6379, // Default Redis port
+        }
+
+    },
+    genkitApiKey: process.env.GENKIT_API_KEY,
+    openaiApiKey: process.env.OPENAI_API_KEY,
+    defaultModel: 'gemini15Flash',
+    experimentalModel: 'gemini20FlashExp',
+    temperature: 1.1,
+};

package/src/conversation.js

@@ -0,0 +1,156 @@
+// conversation.js
+const { pgClient, redisClient } = require('./database');
+const ai = require('./ai');
+const {gemini15Flash} = require("@genkit-ai/googleai");
+
+const saveConversationSummary = async (conversationId, userId, summary) => {
+    const query = `
+        INSERT INTO conversations (conversation_id, user_id, summary)
+        VALUES ($1, $2, $3)
+        ON CONFLICT (conversation_id)
+        DO UPDATE SET summary = EXCLUDED.summary
+        RETURNING *;
+    `;
+    const values = [conversationId, userId, summary];
+    try {
+        const res = await pgClient.query(query, values);
+        await redisClient.set(`summary:${userId}`, summary, { EX: 3600 });
+        return res.rows[0];
+    } catch (err) {
+        console.error('Error saving conversation summary:', err);
+        throw err;
+    }
+};
+
+const generateConversationSummary = async (chatHistory) => {
+    if (!chatHistory || chatHistory.length === 0) {
+        return "No conversation history available.";
+    }
+    const summaryPrompt = `Summarize the following conversation, getting all important information, especially the user's hair details, name, and location: ${JSON.stringify(chatHistory)}`;
+    const { text } = await ai.chat({
+        model: gemini15Flash,
+        system: summaryPrompt,
+    });
+    return text;
+};
+
+const getAllConversationsSummary = async (userId) => {
+    try {
+        // Check Redis cache first
+        const cachedSummary = await redisClient.get(`summary:${userId}`);
+        if (cachedSummary) return cachedSummary;
+
+        // If not in Redis, query PostgreSQL
+        const query = `SELECT summary FROM conversations WHERE user_id = $1 ORDER BY created_at DESC LIMIT 1;`;
+        const values = [userId];
+        const res = await pgClient.query(query, values);
+
+        if (Array.isArray(res.rows) && res.rows.length > 0 && res.rows[0]?.summary) {
+            // Cache the summary in Redis
+            await redisClient.set(`summary:${userId}`, res.rows[0].summary, { EX: 3600 }); // Cache for 1 hour
+            return res.rows[0].summary;
+        }
+
+        return 'conversation summary not available.'; // No summary available
+    } catch (err) {
+        console.error('Error retrieving all conversations summary:', err);
+        return 'conversation summary not available.';
+    }
+};
+
+const getConversationHistory = async (conversationId, userId) => {
+    try {
+        // Check Redis cache first
+        const cachedConversation = await redisClient.get(`conversation:${conversationId}`);
+        if (cachedConversation) return JSON.parse(cachedConversation).chatHistory;
+
+        // If not in Redis, query PostgreSQL
+        const query = `SELECT chat_history FROM conversations WHERE conversation_id = $1 AND user_id = $2;`;
+        const values = [conversationId, userId];
+        const res = await pgClient.query(query, values);
+
+        if (res.rows[0]) {
+            // Cache the conversation history in Redis
+            await redisClient.set(`conversation:${conversationId}`, JSON.stringify({ chatHistory: res.rows[0].chat_history }));
+            return res.rows[0].chat_history;
+        }
+
+        return []; // New conversation
+    } catch (err) {
+        console.error('Error retrieving conversation history:', err);
+        return []; // New conversation
+    }
+};
+
+const saveConversation = async (conversationId, userId, chatHistory, summary) => {
+    const query = `
+        INSERT INTO conversations (conversation_id, user_id, chat_history, summary)
+        VALUES ($1, $2, $3, $4)
+        ON CONFLICT (conversation_id)
+        DO UPDATE SET chat_history = EXCLUDED.chat_history, summary = EXCLUDED.summary
+        RETURNING *;
+    `;
+    const res = await pgClient.query(query, [conversationId, userId, JSON.stringify(chatHistory), summary]);
+    await redisClient.set(`conversation:${conversationId}`, JSON.stringify({ chatHistory: chatHistory }));
+    return res.rows[0];
+};
+
+const getAllChatsAsSingleArray = async (userId) => {
+    try {
+        const query = `
+            SELECT chat_history
+            FROM conversations
+            WHERE user_id = $1
+            ORDER BY created_at ASC;
+        `;
+        const values = [userId];
+
+        const res = await pgClient.query(query, values);
+
+        if (!res.rows || res.rows.length === 0) {
+            return [];
+        }
+
+        let allChats = [];
+
+        for (const row of res.rows) {
+            if (row.chat_history && Array.isArray(row.chat_history)) {
+                allChats = allChats.concat(row.chat_history);
+            } else if (row.chat_history) {
+                try {
+                    const parsedHistory = JSON.parse(row.chat_history);
+                    if (Array.isArray(parsedHistory)) {
+                        allChats = allChats.concat(parsedHistory);
+                    } else {
+                        console.warn(`Unexpected chat_history format for user ${userId}:`, row.chat_history);
+                    }
+                } catch (parseError) {
+                    console.error(`Error parsing chat_history for user ${userId}:`, parseError, row.chat_history);
+                }
+            }
+        }
+
+        return allChats;
+
+    } catch (err) {
+        console.error('Error retrieving all chats:', err);
+        return [];
+    }
+};
+
+const generateAndSaveSummary = async (userId, conversationId, chatHistory) => {
+    const allChatz = await getAllChatsAsSingleArray(userId);
+    const newSummary = await generateConversationSummary(allChatz.length ? allChatz : chatHistory);
+    await saveConversationSummary(conversationId, userId, newSummary);
+    return newSummary;
+};
+
+module.exports = {
+    saveConversationSummary,
+    generateConversationSummary,
+    getAllConversationsSummary,
+    getConversationHistory,
+    saveConversation,
+    getAllChatsAsSingleArray,
+    generateAndSaveSummary
+};

package/src/database.js

@@ -0,0 +1,26 @@
+// database.js
+const { Client } = require('pg');
+const { createClient } = require('redis');
+const config = require('./config');
+require('dotenv').config();
+
+const pgClient = new Client(config.dbConfig);
+const redisClient = createClient(config.redisConfig);
+redisClient.on('error', (err) => console.error('Redis error:', err));
+
+const connectDatabases = async () => {
+    try {
+        await pgClient.connect();
+        await redisClient.connect();
+        console.log('Connected to PostgreSQL and Redis');
+    } catch (err) {
+        console.error('Database connection error:', err);
+        process.exit(1);
+    }
+};
+
+module.exports = {
+    pgClient,
+    redisClient,
+    connectDatabases,
+};

package/src/hairIssues.js

@@ -0,0 +1,40 @@
+// hairIssues.js
+const { pgClient } = require('./database');
+
+const saveHairIssue = async (userId, issueDescription, botAdvice) => {
+    const query = `
+        INSERT INTO hair_issues (user_id, issue_description, bot_advice, advice_given_at)
+        VALUES ($1, $2, $3, NOW())
+        RETURNING *;
+    `;
+    const values = [userId, issueDescription, botAdvice];
+    try {
+        const res = await pgClient.query(query, values);
+        return res.rows[0];
+    } catch (err) {
+        console.error('Error saving hair issue:', err);
+        return [];
+    }
+};
+
+const getHairIssuesForUser = async (userId) => {
+    const query = `
+        SELECT *
+        FROM hair_issues
+        WHERE user_id = $1
+        ORDER BY reported_at DESC;
+    `;
+    const values = [userId];
+    try {
+        const res = await pgClient.query(query, values);
+        return res.rows; // Returns an array of hair issue objects
+    } catch (err) {
+        console.error('Error retrieving hair issues for user:', err);
+        return []
+    }
+};
+
+module.exports = {
+    saveHairIssue,
+    getHairIssuesForUser
+}

package/src/index.js

@@ -0,0 +1,28 @@
+// Re-export all shared modules
+module.exports = {
+    // Database and utilities
+    connectDatabases: require('./src/database').connectDatabases,
+    pgClient: require('./src/database').pgClient,
+    redisClient: require('./src/database').redisClient,
+  
+    // AI and session management
+    ai: require('./src/ai'),
+    DatabaseSessionStore: require('./src/session'),
+  
+    // User and conversation management
+    getUserDetails: require('./src/user').getUserDetails,
+    getAllConversationsSummary: require('./src/conversation').getAllConversationsSummary,
+    getConversationHistory: require('./src/conversation').getConversationHistory,
+    saveConversation: require('./src/conversation').saveConversation,
+    generateConversationSummary: require('./src/conversation').generateConversationSummary,
+  
+    // Post-processing and hair issues
+    postProcessConversation: require('./src/postResponseProcessing').postProcessConversation,
+    postResponseProcessing: require('./src/postResponseProcessing').postResponseProcessing,
+    saveHairIssue: require('./src/hairIssues').saveHairIssue,
+    getHairIssuesForUser: require('./src/hairIssues').getHairIssuesForUser,
+  
+    // Utilities
+    getAllProducts: require('./src/utils').getAllProducts,
+    getAllFaqs: require('./src/utils').getAllFaqs,
+  };

package/src/postResponseProcessing.js

@@ -0,0 +1,205 @@
+// postResponseProcessing.js
+const ai = require("./ai");
+const {gemini15Flash} = require("@genkit-ai/googleai");
+const DatabaseSessionStore = require("./session");
+const { pgClient, redisClient } = require('./database');
+const {generateAndSaveSummary, saveConversationSummary, saveConversation} = require("./conversation");
+const {saveHairIssue} = require("./hairIssues");
+const {postProcessingPrompt} = require("./constructPrompt");
+
+
+const processBotResponse = (botResponse) => {
+    if (!botResponse || !Array.isArray(botResponse) || botResponse.length === 0) {
+        return "No bot response received.";
+    }
+
+    let processedResponse = "";
+    for (const responseItem of botResponse) {
+        const messageType = responseItem.messageType;
+        const message = responseItem.message;
+        const metadata = responseItem.metadata;
+
+        if (messageType === 'html') {
+            // Extract plain text from HTML message (basic - can be improved for complex HTML)
+            const plainText = message ? message.replace(/<[^>]*>?/gm, '').trim() : '';
+            processedResponse += `Text Response: ${plainText}\n`;
+        } else if (metadata && metadata.templateId) {
+            const templateId = metadata.templateId;
+            if (templateId === '10') { // card
+                const payload = metadata.payload && metadata.payload[0];
+                if (payload) {
+                    processedResponse += `Service Card: ${payload.title || 'No Title'}, ${payload.subtitle || 'No Subtitle'}, URL: ${payload.buttons && payload.buttons[0] && payload.buttons[0].action && payload.buttons[0].action.payload ? payload.buttons[0].action.payload.url : 'No URL'}\n`;
+                } else {
+                    processedResponse += "Service Card: (No details extracted)\n";
+                }
+            } else if (templateId === '9') { // Image carousel
+                const payload = metadata.payload;
+                if (payload && Array.isArray(payload)) {
+                    processedResponse += "Image Carousel: ";
+                    payload.forEach((image, index) => {
+                        processedResponse += `Image ${index + 1} - Caption: ${image.caption || 'No Caption'}, URL: ${image.url || 'No URL'}; `;
+                    });
+                    processedResponse += "\n";
+                } else {
+                    processedResponse += "Image Carousel: (No images extracted)\n";
+                }
+            } else if (templateId === '3') { // Button template
+                const payload = metadata.payload && metadata.payload[0];
+                if (payload) {
+                    processedResponse += `Button: ${payload.name || 'No Name'}, URL: ${payload.url || 'No URL'}\n`;
+                } else {
+                    processedResponse += "Button: (No button details extracted)\n";
+                }
+            } else if (templateId === '6') { // Suggested replies
+                const payload = metadata.payload;
+                if (payload && Array.isArray(payload)) {
+                    processedResponse += "Suggested Replies: ";
+                    payload.forEach((reply, index) => {
+                        processedResponse += `${reply.title || 'Reply ' + (index + 1)}; `;
+                    });
+                    processedResponse += "\n";
+                } else {
+                    processedResponse += "Suggested Replies: (No replies extracted)\n";
+                }
+            } else if (templateId === '7') { // List template (Welcome message)
+                processedResponse += "Welcome Message Card (List Template)\n"; // Simplified for brevity
+            }
+            else {
+                processedResponse += `Unknown Card Template (ID: ${templateId}): Message: ${message}\n`;
+            }
+        }
+        else if (message) { // Fallback for any other message type (or just plain text if no html)
+            processedResponse += `Raw Message: ${message}\n`;
+        }
+        else {
+            processedResponse += `Unknown Response Type: No message content found.\n`;
+        }
+    }
+
+    return processedResponse.trim(); // Remove trailing newline and whitespace
+};
+
+const postProcessConversation = async (chatHistory, message) => {
+
+
+    const extractionPrompt = await postProcessingPrompt(chatHistory, message);
+    console.log('Extraction prompt: ', extractionPrompt);
+    try {
+        const chat = ai.chat({
+            model: gemini15Flash,
+            config: {
+                temperature: 1.1,
+            },
+
+        });
+        const { output } = await chat.send(extractionPrompt);
+        console.log("Raw post-processing output:", JSON.stringify(output));
+
+        if (!output) {
+            console.warn("Post-processing output is empty. Returning default empty JSON.");
+            return {}; // Or return a default empty JSON object based on your schema if needed
+        }
+
+        return output;
+    } catch (error) {
+        console.error("Error in postProcessConversation:", error);
+        return {}; // Return empty object in case of error
+    }
+};
+
+const updateUserProfile = async (userId, updates) => {
+    if (!updates || Object.keys(updates).length === 0) {
+        console.log("No user profile updates to apply.");
+        return null; // No updates to apply
+    }
+
+    // Filter out null or undefined values from updates
+    const validUpdates = Object.entries(updates)
+        .filter(([key, value]) => value !== null && value !== undefined)
+        .reduce((obj, [key, value]) => {
+            obj[key] = value;
+            return obj;
+        }, {});
+
+    if (Object.keys(validUpdates).length === 0) {
+        console.log("No valid user profile updates to apply (all values were null or undefined).");
+        return null; // No valid updates to apply
+    }
+    // Update chat session state here
+   try {
+       const session = await ai.loadSession(userId, {
+           store: new DatabaseSessionStore(),
+       });
+
+       // Update the session state
+       await session.updateState({
+           userProfile: validUpdates,
+           lastInteractionTime: new Date().toISOString(),
+           // ... any other state properties you need to update
+       });
+
+   }catch (e){
+        console.log(e)
+   }
+
+    const updateKeys = Object.keys(validUpdates);
+    const updateValues = updateKeys.map(key => validUpdates[key]);
+
+    const setClauses = updateKeys.map((key, index) => `${key} = $${index + 2}`).join(', '); // Start parameter index from 2
+
+    const query = {
+        text: `
+            UPDATE users
+            SET ${setClauses}, updated_at = NOW()
+            WHERE user_id = $1
+            RETURNING *;
+        `,
+        values: [userId, ...updateValues], // userId is $1, updates are $2, $3, ...
+    };
+
+    try {
+        const res = await pgClient.query(query);
+        if (res.rows.length > 0) {
+            // Update Redis cache with the updated user profile
+            await redisClient.set(`user:${userId}`, JSON.stringify(res.rows[0]));
+            console.log(`User profile updated successfully for user ${userId} with fields: ${updateKeys.join(', ')}`);
+            return res.rows[0]; // Return the updated user object
+        } else {
+            console.warn(`User profile update failed for user ${userId}: User not found.`);
+            return null; // User not found or update failed
+        }
+    } catch (err) {
+        console.error(`Error updating user profile for user ${userId}:`, err);
+        throw err; // Propagate the error
+    }
+};
+
+const postResponseProcessing = async (postProcessData, userId, output, allchatsSummary, conversationId, chatHistory )=>{
+    if (postProcessData.user_profile_updates) {
+        // TODO: Update user profile in database based on postProcessData.user_profile_updates
+        console.log("User profile updates to be applied:", postProcessData.user_profile_updates);
+        await updateUserProfile(userId, postProcessData.user_profile_updates);
+    }
+
+    if (postProcessData.hair_issue_extractions && postProcessData.hair_issue_extractions.hair_issues_reported && postProcessData.hair_issue_extractions.hair_issues_reported.length > 0) {
+        for (const issue of postProcessData.hair_issue_extractions.hair_issues_reported) {
+            await saveHairIssue(userId, issue, JSON.stringify(output)); // Or refine advice from output
+            console.log(`Hair issue reported and saved: ${issue}`);
+        }
+    }
+
+
+    if (!allchatsSummary) {
+        await generateAndSaveSummary(userId, conversationId, chatHistory);
+    }
+
+    await saveConversationSummary(conversationId, userId, allchatsSummary);
+    return await saveConversation(conversationId, userId, chatHistory, allchatsSummary);
+};
+
+module.exports = {
+    postResponseProcessing,
+    postProcessConversation,
+    processBotResponse,
+    updateUserProfile
+}

package/src/session.js

@@ -0,0 +1,41 @@
+// session.js
+const { pgClient } = require('./database');
+
+class DatabaseSessionStore {
+    async get(sessionId) {
+        const query = `
+            SELECT session_data
+            FROM sessions
+            WHERE session_id = $1;
+        `;
+        const values = [sessionId];
+        try {
+            const res = await pgClient.query(query, values);
+            if (res.rows.length > 0 && res.rows[0].session_data) {
+                return res.rows[0].session_data;
+            }
+            return undefined; // Session not found or no data
+        } catch (err) {
+            console.error('Error retrieving session data from database:', err);
+            return undefined;
+        }
+    }
+
+    async save(sessionId, sessionData) {
+        const query = `
+            INSERT INTO sessions (session_id, user_id, session_data, last_accessed_at)
+            VALUES ($1, $2, $3, NOW())
+            ON CONFLICT (session_id)
+            DO UPDATE SET session_data = $3, last_accessed_at = NOW();
+        `;
+        const values = [sessionId, sessionId, sessionData];
+        try {
+            await pgClient.query(query, values);
+            console.log(`Session data saved to database for sessionId: ${sessionId}`);
+        } catch (err) {
+            console.error('Error saving session data to database:', err);
+        }
+    }
+}
+
+module.exports = DatabaseSessionStore;

package/src/user.js

@@ -0,0 +1,37 @@
+// user.js
+const { pgClient, redisClient } = require('./database');
+
+const getUserDetails = async (userId) => {
+    try {
+        const cachedUser = await redisClient.get(`user:${userId}`);
+        if (cachedUser) return JSON.parse(cachedUser);
+
+        const query = `SELECT * FROM users WHERE user_id = $1;`;
+        const values = [userId];
+        const res = await pgClient.query(query, values);
+
+        if (res.rows[0]) {
+            await redisClient.set(`user:${userId}`, JSON.stringify(res.rows[0]));
+            return res.rows[0];
+        }
+
+        const createUserQuery = `
+            INSERT INTO users (user_id)
+            VALUES ($1)
+            RETURNING *;
+        `;
+        const createUserRes = await pgClient.query(createUserQuery, [userId]);
+        if (createUserRes.rows[0]) {
+            await redisClient.set(`user:${userId}`, JSON.stringify(createUserRes.rows[0]));
+            return createUserRes.rows[0];
+        }
+        return null;
+    } catch (err) {
+        console.error('Error retrieving user details:', err);
+        throw err;
+    }
+};
+
+module.exports = {
+    getUserDetails,
+};

package/src/utils.js

@@ -0,0 +1,32 @@
+const { pgClient } = require('./database'); // Import pgClient from core's database.js
+
+async function getAllProducts() {
+  try {
+    const result = await pgClient.query('SELECT * FROM products');
+    return result.rows;
+  } catch (error) {
+    console.error("Error fetching all products:", error);
+    return [];
+  }
+}
+
+async function getAllFaqs() {
+  try {
+    const result = await pgClient.query('SELECT * FROM faqs');
+    return result.rows;
+  } catch (error) {
+    console.error("Error fetching all FAQs:", error);
+    return [];
+  }
+}
+
+async function getHairIssuesForUser(userId) {
+  // Return empty for now (or implement logic later)
+  return [];
+}
+
+module.exports = {
+  getAllProducts,
+  getAllFaqs,
+  getHairIssuesForUser,
+};